doc
Module Contents
alltypes
Module Contents
object absolute : Keyword
abstract class AbstractTextObjectFormatter : TextObjectFormatterCommon
object aDirectory : Keyword
class All<out T> : VarArgHelper<T>
object anEmptyDirectory : Keyword
interface AnyAssertions
Module Contents
abstract fun <T> because(container: AssertionContainer<T>, reason: String, assertionCreator: Expect<T>.() -> Unit): Assertion
abstract fun <T, TSub : Any> isA(container: AssertionContainer<T>, subType: KClass<TSub>): SubjectChangerBuilder.ExecutionStep<T, TSub>
abstract fun <T> isNotIn(container: AssertionContainer<T>, expected: Iterable<T>): Assertion
abstract fun <T> isNotSameAs(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T> isSameAs(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T> notToBe(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T : Any> notToBeNullButOfType(container: AssertionContainer<T?>, subType: KClass<T>): SubjectChangerBuilder.ExecutionStep<T?, T>
abstract fun <T> toBe(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T : Any> toBeNullIfNullGivenElse(container: AssertionContainer<T?>, assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Assertion
object aRegularFile : Keyword
class ArgumentMapperBuilder<out T>
abstract class ArgumentsSupportingTranslator : Translator
class ArgumentToNullOrMapperBuilder<T : Any>
interface Assertion
interface AssertionBuilder
Module Contents
open fun createDescriptive(description: String, representation: Any?, test: () -> Boolean): DescriptiveAssertion
open fun createDescriptive(description: Translatable, representation: Any?, test: () -> Boolean): DescriptiveAssertion
open fun <T> createDescriptive(expect: Expect<T>, description: String, representation: Any?, test: (T) -> Boolean): DescriptiveAssertion
open fun <T> createDescriptive(expect: Expect<T>, description: Translatable, representation: Any?, test: (T) -> Boolean): DescriptiveAssertion
abstract fun <T : AssertionGroupType> customType(groupType: T): DefaultAssertionGroupBuilderOptions<T>
abstract val descriptive: Descriptive.HoldsOption
abstract val explanatory: Explanatory.ExplanationOption
abstract val explanatoryGroup: ExplanatoryAssertionGroupTypeOption
abstract val feature: DefaultAssertionGroupBuilderOptions<FeatureAssertionGroupType>
abstract val list: DefaultAssertionGroupBuilderOptions<ListAssertionGroupType>
abstract val representationOnly: RepresentationOnly.HoldsStep
abstract val summary: AssertionGroupDescriptionAndEmptyRepresentationOption<SummaryAssertionGroupType, AssertionsOption<SummaryAssertionGroupType, BasicAssertionGroupFinalStep>>
interface AssertionBuilderFinalStep<T : Assertion>
interface AssertionContainer<T> : SubjectProvider<T>
interface AssertionFormatter
interface AssertionFormatterController
class AssertionFormatterControllerBasedFacade : AssertionFormatterFacade
interface AssertionFormatterFacade
class AssertionFormatterParameterObject
interface AssertionGroup : Assertion
interface AssertionGroupDescriptionAndEmptyRepresentationOption<out T : AssertionGroupType, R>
interface AssertionGroupDescriptionAndRepresentationOption<out T : AssertionGroupType, R>
interface AssertionGroupType : BulletPointIdentifier
interface AssertionPairFormatter
interface AssertionsOption<out T : AssertionGroupType, out R>
Module Contents
fun <T : AssertionGroupType, R> create(groupType: T, description: Translatable, representation: Any, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>
abstract val description: Translatable
fun <T : AssertionGroupType> factoryWithDefaultFinalStep(): (T, Translatable, Any) -> AssertionsOption<T, BasicAssertionGroupFinalStep>
abstract val groupType: T
abstract val representation: Any
open fun withAssertion(assertion: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion, assertion3: Assertion): R
abstract fun withAssertions(assertions: List<Assertion>): R
fun <T : AssertionGroupType> withDefaultFinalStepAndEmptyDescriptionAndRepresentation(groupType: T): AssertionsOption<T, BasicAssertionGroupFinalStep>
fun <T : AssertionGroupType, R> withEmptyDescriptionAndRepresentation(groupType: T, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>
enum class AssertionVerb : StringBasedTranslatable
object aSuccess : Keyword
object aSymbolicLink : Keyword
interface AtLeastChecker : WithTimesChecker
interface AtLeastChecker : AtLeastChecker, CharSequenceContains.Checker
interface AtLeastChecker : AtLeastChecker, IterableLikeContains.Checker
interface AtLeastChecker : AtLeastChecker, MapLikeContains.Checker
interface AtLeastCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>
interface AtLeastCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>
interface AtMostChecker : WithTimesChecker
interface AtMostChecker : AtMostChecker, CharSequenceContains.Checker
interface AtMostChecker : AtMostChecker, IterableLikeContains.Checker
interface AtMostChecker : AtMostChecker, MapLikeContains.Checker
interface AtMostCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>
interface AtMostCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>
class AtMostCheckerStepImpl<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtMostCheckerStep<T, S>, CharSequenceContains.CheckerStepInternal<T, S>
expect class AtriumError : AssertionError
expect interface AtriumErrorAdjuster : AtriumErrorAdjusterCommon
interface AtriumErrorAdjusterCommon
abstract class BaseExpectImpl<T> : ExpectInternal<T>
abstract class BaseTransformationExecutionStep<T, R, E : Expect<R>> : TransformationExecutionStep<T, R, E>
interface BasicAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>
interface BigDecimalAssertions
object blank : Keyword
interface BulletPointIdentifier
interface BulletPointProvider
interface ButAtMostCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>
interface ButAtMostCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>
class ButAtMostCheckerStepImpl<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ButAtMostCheckerStep<T, S>, CharSequenceContains.CheckerStepInternal<T, S>
Module Contents
ButAtMostCheckerStepImpl(times: Int, atLeastBuilder: WithTimesCheckerStepLogic<T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String, atMostCall: (Int) -> String, entryPointStepLogic: CharSequenceContains.EntryPointStepLogic<T, S>)
val checkers: List<CharSequenceContains.Checker>
val entryPointStepLogic: CharSequenceContains.EntryPointStepLogic<T, S>
object case : Keyword
interface CharSequenceAssertions
interface CharSequenceContains
Module Contents
interface Checker : Contains.Checker
interface CheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.CheckerStep<T, S, CharSequenceContains.Checker, CharSequenceContains.EntryPointStep<T, S>>
interface CheckerStepInternal<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStep<T, S>, CharSequenceContains.CheckerStepLogic<T, S>
interface CheckerStepLogic<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.CheckerStepLogic<T, S, CharSequenceContains.Checker, CharSequenceContains.EntryPointStepLogic<T, S>>
interface Creator<T : CharSequence, in SC> : Contains.Creator<T, SC>
interface EntryPointStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.EntryPointStep<T, S>
interface EntryPointStepInternal<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.EntryPointStep<T, S>, CharSequenceContains.EntryPointStepLogic<T, S>
interface EntryPointStepLogic<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.EntryPointStepLogic<T, S>
interface SearchBehaviour : Contains.SearchBehaviour
interface Searcher<S : CharSequenceContains.SearchBehaviour, SC>
class CharSequenceContainsAssertionCreator<T : CharSequence, in SC : Any, S : CharSequenceContains.SearchBehaviour> : ContainsObjectsAssertionCreator<T, String, SC, S, CharSequenceContains.Checker>, CharSequenceContains.Creator<T, SC>
interface CharSequenceContainsAssertions
typealias CharSequenceOrNumberOrChar = Any
interface ChronoLocalDateAssertions
Module Contents
abstract fun <T : ChronoLocalDate> isAfter(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isAfter(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDate> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDate> isBefore(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isBefore(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDate> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDate> isEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isEqual(container: AssertionContainer<T>, expected: String): Assertion
interface ChronoLocalDateTimeAssertions
Module Contents
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: String): Assertion
interface ChronoZonedDateTimeAssertions
Module Contents
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: String): Assertion
interface CollectingExpect<T> : Expect<T>
typealias CollectionLike = Any
interface CollectionLikeAssertions
interface ComparableAssertions
Module Contents
abstract fun <T1 : Comparable<T2>, T2> isEqualComparingTo(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isGreaterThan(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isGreaterThanOrEqual(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isLessThan(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isLessThanOrEqual(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isNotGreaterThan(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isNotLessThan(container: AssertionContainer<T1>, expected: T2): Assertion
data class ComponentFactory
interface ComponentFactoryContainer
interface Contains
Module Contents
interface Checker
interface CheckerStep<T : Any, out S : Contains.SearchBehaviour, out C : Contains.Checker, out B : Contains.EntryPointStep<T, S>>
interface CheckerStepLogic<T : Any, out S : Contains.SearchBehaviour, out C : Contains.Checker, out B : Contains.EntryPointStepLogic<T, S>>
interface Creator<T, in SC>
interface EntryPointStep<T : Any, out S : Contains.SearchBehaviour>
interface EntryPointStepLogic<T : Any, out S : Contains.SearchBehaviour>
interface SearchBehaviour
abstract class ContainsAssertionCreator<T : Any, TT : Any, in SC, C : Contains.Checker> : Contains.Creator<T, SC>
abstract class ContainsChecker : Contains.Checker
abstract class ContainsObjectsAssertionCreator<T : Any, TT : Any, in SC, S : Contains.SearchBehaviour, C : Contains.Checker> : ContainsAssertionCreator<T, TT, SC, C>
expect interface CoreFactory : CoreFactoryCommon
interface CoreFactoryCommon
Module Contents
abstract fun newAssertionFormatterController(): AssertionFormatterController
abstract fun newAssertionFormatterFacade(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacade
abstract fun newDetailedObjectFormatter(translator: Translator): ObjectFormatter
abstract fun newLocaleOrderDecider(): LocaleOrderDecider
abstract fun newMethodCallFormatter(): MethodCallFormatter
abstract fun newMultiAtriumErrorAdjuster(firstAdjuster: AtriumErrorAdjuster, secondAdjuster: AtriumErrorAdjuster, otherAdjusters: List<AtriumErrorAdjuster>): AtriumErrorAdjuster
abstract fun newNoOpAtriumErrorAdjuster(): AtriumErrorAdjuster
abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade, atriumErrorAdjuster: AtriumErrorAdjuster): Reporter
abstract fun newRemoveAtriumFromAtriumErrorAdjuster(): AtriumErrorAdjuster
abstract fun newRemoveRunnerAtriumErrorAdjuster(): AtriumErrorAdjuster
abstract fun newTextExplanatoryAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController): AssertionFormatter
abstract fun newTextFallbackAssertionFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextFeatureAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextListAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextNextLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newTextSameLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newTextSummaryAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTranslator(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider, primaryLocale: Locale, fallbackLocales: List<Locale>): Translator
abstract fun registerTextAssertionFormatterCapabilities(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterFacade: AssertionFormatterFacade, textAssertionPairFormatter: AssertionPairFormatter, objectFormatter: ObjectFormatter, translator: Translator): Unit
class DefaultAnyAssertions : AnyAssertions
Module Contents
DefaultAnyAssertions()
fun <T> because(container: AssertionContainer<T>, reason: String, assertionCreator: Expect<T>.() -> Unit): Assertion
fun <T, TSub : Any> isA(container: AssertionContainer<T>, subType: KClass<TSub>): SubjectChangerBuilder.ExecutionStep<T, TSub>
fun <T> isNotIn(container: AssertionContainer<T>, expected: Iterable<T>): Assertion
fun <T> isNotSameAs(container: AssertionContainer<T>, expected: T): Assertion
fun <T> isSameAs(container: AssertionContainer<T>, expected: T): Assertion
fun <T> notToBe(container: AssertionContainer<T>, expected: T): Assertion
fun <T : Any> notToBeNullButOfType(container: AssertionContainer<T?>, subType: KClass<T>): SubjectChangerBuilder.ExecutionStep<T?, T>
fun <T> toBe(container: AssertionContainer<T>, expected: T): Assertion
fun <T : Any> toBeNullIfNullGivenElse(container: AssertionContainer<T?>, assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Assertion
class DefaultAssertionFormatterController : AssertionFormatterController
typealias DefaultAssertionGroupBuilderOptions<T> = AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, BasicAssertionGroupFinalStep>>
class DefaultAtLeastChecker : AtLeastChecker, ContainsChecker
class DefaultAtLeastChecker : AtLeastChecker, ContainsChecker
class DefaultAtLeastChecker : AtLeastChecker, ContainsChecker
class DefaultAtMostChecker : AtMostChecker, ContainsChecker
class DefaultAtMostChecker : AtMostChecker, ContainsChecker
class DefaultAtMostChecker : AtMostChecker, ContainsChecker
class DefaultBigDecimalAssertions : BigDecimalAssertions
class DefaultCharSequenceAssertions : CharSequenceAssertions
class DefaultCharSequenceContainsAssertions : CharSequenceContainsAssertions
class DefaultChronoLocalDateAssertions : ChronoLocalDateAssertions
Module Contents
DefaultChronoLocalDateAssertions()
fun <T : ChronoLocalDate> isAfter(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isAfter(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDate> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDate> isBefore(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isBefore(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDate> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDate> isEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isEqual(container: AssertionContainer<T>, expected: String): Assertion
class DefaultChronoLocalDateTimeAssertions : ChronoLocalDateTimeAssertions
Module Contents
DefaultChronoLocalDateTimeAssertions()
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: String): Assertion
class DefaultChronoZonedDateTimeAssertions : ChronoZonedDateTimeAssertions
Module Contents
DefaultChronoZonedDateTimeAssertions()
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: String): Assertion
class DefaultCollectionLikeAssertions : CollectionLikeAssertions
class DefaultComparableAssertions : ComparableAssertions
Module Contents
DefaultComparableAssertions()
fun <T1 : Comparable<T2>, T2> isEqualComparingTo(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isGreaterThan(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isGreaterThanOrEqual(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isLessThan(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isLessThanOrEqual(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isNotGreaterThan(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isNotLessThan(container: AssertionContainer<T1>, expected: T2): Assertion
object DefaultComponentFactoryContainer : ComponentFactoryContainer
class DefaultExactlyChecker : ExactlyChecker, ContainsChecker
class DefaultExactlyChecker : ExactlyChecker, ContainsChecker
class DefaultExactlyChecker : ExactlyChecker, ContainsChecker
object DefaultExplanatoryAssertionGroupType : ExplanatoryAssertionGroupType
class DefaultFailureHandlerImpl<T, R> : SubjectChanger.FailureHandler<T, R>
object DefaultFeatureAssertionGroupType : FeatureAssertionGroupType
class DefaultFeatureAssertions : FeatureAssertions
Module Contents
DefaultFeatureAssertions()
fun <T, R> f0(container: AssertionContainer<T>, f: KFunction1<T, R>): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, R> f1(container: AssertionContainer<T>, f: KFunction2<T, A1, R>, a1: A1): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, A2, R> f2(container: AssertionContainer<T>, f: KFunction3<T, A1, A2, R>, a1: A1, a2: A2): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, A2, A3, R> f3(container: AssertionContainer<T>, f: KFunction4<T, A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, A2, A3, A4, R> f4(container: AssertionContainer<T>, f: KFunction5<T, A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, A2, A3, A4, A5, R> f5(container: AssertionContainer<T>, f: KFunction6<T, A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, R> manualFeature(container: AssertionContainer<T>, description: Translatable, provider: T.() -> R): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, TProperty> property(container: AssertionContainer<T>, property: KProperty1<in T, TProperty>): FeatureExtractorBuilder.ExecutionStep<T, TProperty>
class DefaultFeatureExtractor : FeatureExtractor
class DefaultFloatingPointAssertions : FloatingPointAssertions
class DefaultFloatingPointJvmAssertions : FloatingPointJvmAssertions
class DefaultFun0Assertions : Fun0Assertions
class DefaultIterableLikeAssertions : IterableLikeAssertions
Module Contents
DefaultIterableLikeAssertions()
fun <T, E> all(container: AssertionContainer<T>, converter: (T) -> Iterable<E?>, assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Assertion
fun <T, E> builderContainsInIterableLike(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>
fun <T, E> builderContainsNotInIterableLike(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): NotCheckerStep<E, T, NotSearchBehaviour>
fun <T, E> containsNoDuplicates(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
fun <T, E> hasNext(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
fun <T, E> hasNotNext(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
fun <T, E : Comparable<E>> max(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): FeatureExtractorBuilder.ExecutionStep<T, E>
fun <T, E : Comparable<E>> min(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): FeatureExtractorBuilder.ExecutionStep<T, E>
class DefaultIterableLikeContainsAssertions : IterableLikeContainsAssertions
Module Contents
DefaultIterableLikeContainsAssertions()
fun <E : Any, T> entriesInAnyOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
fun <E : Any, T> entriesInOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
fun <E : Any, T> entriesInOrderOnlyGrouped(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<(Expect<E>.() -> Unit)?>>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
fun <E, T> valuesInAnyOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): Assertion
fun <E, T> valuesInOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlySearchBehaviour>, expected: List<E>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
fun <E, T> valuesInOrderOnlyGrouped(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
class DefaultIterableLikeContainsInAnyOrderAssertions : IterableLikeContainsInAnyOrderAssertions
class DefaultIterableLikeToIterableTransformer : IterableLikeToIterableTransformer
class DefaultIteratorAssertions : IteratorAssertions
object DefaultListAssertionGroupType : ListAssertionGroupType
class DefaultListAssertions : ListAssertions
class DefaultLocalDateAssertions : LocalDateAssertions
class DefaultLocalDateTimeAssertions : LocalDateTimeAssertions
class DefaultMapEntryAssertions : MapEntryAssertions
Module Contents
DefaultMapEntryAssertions()
fun <K, V, T : Entry<K, V>> isKeyValue(container: AssertionContainer<T>, key: K, value: V): Assertion
fun <K, T : Entry<K, *>> key(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, K>
fun <V, T : Entry<*, V>> value(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, V>
class DefaultMapLikeAssertions : MapLikeAssertions
Module Contents
DefaultMapLikeAssertions()
fun <T, K, V> builderContainsInMapLike(container: AssertionContainer<T>, converter: (T) -> Map<out K, V>): MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>
fun <K, T> containsKey(container: AssertionContainer<T>, converter: (T) -> Map<out K, *>, key: K): Assertion
fun <K, T> containsNotKey(container: AssertionContainer<T>, converter: (T) -> Map<out K, *>, key: K): Assertion
fun <K, V, T> getExisting(container: AssertionContainer<T>, converter: (T) -> Map<out K, V>, key: K): FeatureExtractorBuilder.ExecutionStep<T, V>
class DefaultMapLikeContainsAssertions : MapLikeContainsAssertions
Module Contents
DefaultMapLikeContainsAssertions()
fun <K, V, T> keyValuePairsInAnyOrder(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InAnyOrderSearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
fun <K, V, T> keyValuePairsInAnyOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InAnyOrderOnlySearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
fun <K, V, T> keyValuePairsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InOrderOnlySearchBehaviour>, keyValuePairs: List<Pair<K, V>>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
fun <K, V : Any, T> keyWithValueAssertionsInAnyOrder(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InAnyOrderSearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
fun <K, V : Any, T> keyWithValueAssertionsInAnyOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InAnyOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
fun <K, V : Any, T> keyWithValueAssertionsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
fun <K, V : Any, T> keyWithValueAssertionsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
class DefaultMapLikeToIterablePairTransformer : MapLikeToIterablePairTransformer
class DefaultNotChecker : NotChecker
class DefaultNotChecker : NotChecker
class DefaultNotChecker : NotChecker
class DefaultOptionalAssertions : OptionalAssertions
class DefaultPairAssertions : PairAssertions
class DefaultPathAssertions : PathAssertions
Module Contents
DefaultPathAssertions()
fun <T : Path> endsNotWith(container: AssertionContainer<T>, expected: Path): Assertion
fun <T : Path> endsWith(container: AssertionContainer<T>, expected: Path): Assertion
fun <T : Path> exists(container: AssertionContainer<T>, linkOption: LinkOption?): Assertion
fun <T : Path> existsNot(container: AssertionContainer<T>, linkOption: LinkOption?): Assertion
fun <T : Path> extension(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
fun <T : Path> fileName(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
fun <T : Path> fileNameWithoutExtension(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
fun <T : Path> hasDirectoryEntry(container: AssertionContainer<T>, entries: List<String>): Assertion
fun <T : Path> hasSameBinaryContentAs(container: AssertionContainer<T>, targetPath: Path): Assertion
fun <T : Path> hasSameTextualContentAs(container: AssertionContainer<T>, targetPath: Path, sourceCharset: Charset, targetCharset: Charset): Assertion
fun <T : Path> isAbsolute(container: AssertionContainer<T>): Assertion
fun <T : Path> isDirectory(container: AssertionContainer<T>): Assertion
fun <T : Path> isEmptyDirectory(container: AssertionContainer<T>): Assertion
fun <T : Path> isExecutable(container: AssertionContainer<T>): Assertion
fun <T : Path> isNotExecutable(container: AssertionContainer<T>): Assertion
fun <T : Path> isNotReadable(container: AssertionContainer<T>): Assertion
fun <T : Path> isNotWritable(container: AssertionContainer<T>): Assertion
fun <T : Path> isReadable(container: AssertionContainer<T>): Assertion
fun <T : Path> isRegularFile(container: AssertionContainer<T>): Assertion
fun <T : Path> isRelative(container: AssertionContainer<T>): Assertion
fun <T : Path> isSymbolicLink(container: AssertionContainer<T>): Assertion
fun <T : Path> isWritable(container: AssertionContainer<T>): Assertion
fun <T : Path> parent(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, Path>
fun <T : Path> resolve(container: AssertionContainer<T>, other: String): FeatureExtractorBuilder.ExecutionStep<T, Path>
fun <T : Path> startsNotWith(container: AssertionContainer<T>, expected: Path): Assertion
fun <T : Path> startsWith(container: AssertionContainer<T>, expected: Path): Assertion
class DefaultResultAssertions : ResultAssertions
class DefaultSubjectChanger : SubjectChanger
object DefaultSummaryAssertionGroupType : SummaryAssertionGroupType
object DefaultTextMethodCallFormatter : TextMethodCallFormatter
expect class DefaultTextObjectFormatter : TextObjectFormatter
class DefaultThrowableAssertions : ThrowableAssertions
class DefaultZonedDateTimeAssertions : ZonedDateTimeAssertions
interface DelegatingExpect<T> : Expect<T>
enum class DescriptionAnyAssertion : StringBasedTranslatable
enum class DescriptionBasic : StringBasedTranslatable
enum class DescriptionBigDecimalAssertion : StringBasedTranslatable
enum class DescriptionCharSequenceAssertion : StringBasedTranslatable
enum class DescriptionCollectionAssertion : StringBasedTranslatable
enum class DescriptionComparableAssertion : StringBasedTranslatable
enum class DescriptionDateTimeLikeAssertion : StringBasedTranslatable
enum class DescriptionFloatingPointAssertion : StringBasedTranslatable
enum class DescriptionFunLikeAssertion : StringBasedTranslatable
enum class DescriptionIterableAssertion : StringBasedTranslatable
enum class DescriptionListAssertion : StringBasedTranslatable
enum class DescriptionMapAssertion : StringBasedTranslatable
enum class DescriptionMapLikeAssertion : StringBasedTranslatable
enum class DescriptionOptionalAssertion : StringBasedTranslatable
enum class DescriptionPathAssertion : StringBasedTranslatable
class DescriptionRepresentationStepImpl<T> : SubjectChangerBuilder.DescriptionRepresentationStep<T>
enum class DescriptionResultAssertion : StringBasedTranslatable
class DescriptionStepImpl<T> : FeatureExtractorBuilder.DescriptionStep<T>
enum class DescriptionThrowableAssertion : StringBasedTranslatable
interface Descriptive
interface DescriptiveAssertion : Assertion
interface DescriptiveAssertionWithFailureHint
class DirectoryEntries : VarArgHelper<String>
interface DoNotFilterAssertionGroupType : AssertionGroupType
sealed class Either<out L, out R>
object elements : Keyword
object empty : Keyword
class Entries<T : Any> : Group<(Expect<T>.() -> Unit)?>, VarArgHelper<(Expect<T>.() -> Unit)?>
object entries : Keyword
class Entries<T> : Group<(Expect<T>.() -> Unit)?>, VarArgHelper<(Expect<T>.() -> Unit)?>
class Entry<T : Any> : Group<(Expect<T>.() -> Unit)?>
data class Entry<T : Any> : Group<(Expect<T>.() -> Unit)?>
abstract class EntryPointStepImpl<T : Any, out S : Contains.SearchBehaviour> : Contains.EntryPointStepLogic<T, S>
class EntryPointStepImpl<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : EntryPointStepImpl<T, S>, CharSequenceContains.EntryPointStepInternal<T, S>
class EntryPointStepImpl<E, T, out S : IterableLikeContains.SearchBehaviour> : EntryPointStepImpl<T, S>, IterableLikeContains.EntryPointStepInternal<E, T, S>
class EntryPointStepImpl<K, V, T, out S : MapLikeContains.SearchBehaviour> : EntryPointStepImpl<T, S>, MapLikeContains.EntryPointStepInternal<K, V, T, S>
enum class ErrorMessages : StringBasedTranslatable
enum class ErrorMessages : StringBasedTranslatable
interface ExactlyChecker : WithTimesChecker
interface ExactlyChecker : ExactlyChecker, CharSequenceContains.Checker
interface ExactlyChecker : ExactlyChecker, IterableLikeContains.Checker
interface ExactlyChecker : ExactlyChecker, MapLikeContains.Checker
interface ExactlyCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>
interface ExactlyCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>
object executable : Keyword
class ExecutionStepImpl<T, R> : FeatureExtractorBuilder.ExecutionStep<T, R>, BaseTransformationExecutionStep<T, R, FeatureExpect<T, R>>
class ExecutionStepImpl<T, R> : SubjectChangerBuilder.ExecutionStep<T, R>, BaseTransformationExecutionStep<T, R, Expect<R>>
object existing : Keyword
interface Expect<T> : SubjectProvider<T>
class ExpectationVerbStepImpl<T> : RootExpectBuilder.ExpectationVerbStep<T>
interface ExpectInternal<T> : Expect<T>, AssertionContainer<T>
@DslMarker annotation class ExpectMarker
@Target([AnnotationTarget.FUNCTION, AnnotationTarget.CLASS, AnnotationTarget.PROPERTY, AnnotationTarget.LOCAL_VARIABLE]) annotation class ExperimentalComponentFactoryContainer
@Target([AnnotationTarget.FUNCTION, AnnotationTarget.CLASS]) annotation class ExperimentalFeatureInfo
@Target([AnnotationTarget.FUNCTION, AnnotationTarget.CLASS]) annotation class ExperimentalNewExpectTypes
@Target([AnnotationTarget.FUNCTION]) annotation class ExperimentalWithOptions
@Target([AnnotationTarget.FUNCTION]) annotation class ExperimentalWithOptions
interface Explanatory
interface ExplanatoryAssertion : Assertion
interface ExplanatoryAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>
interface ExplanatoryAssertionGroupType : DoNotFilterAssertionGroupType
interface ExplanatoryAssertionGroupTypeOption
interface ExplanatoryGroup
data class ExtractorWithCreator<T, R>
class Failure : IoResult<Nothing>
class FailureHandlerAdapter<T, R1, R> : SubjectChanger.FailureHandler<T, R>
class FailureHandlerStepImpl<T, R> : SubjectChangerBuilder.FailureHandlerStep<T, R>
data class Feature<T, R>
interface FeatureAssertionGroupType : AssertionGroupType
interface FeatureAssertions
Module Contents
abstract fun <T, R> f0(container: AssertionContainer<T>, f: KFunction1<T, R>): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, R> f1(container: AssertionContainer<T>, f: KFunction2<T, A1, R>, a1: A1): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, A2, R> f2(container: AssertionContainer<T>, f: KFunction3<T, A1, A2, R>, a1: A1, a2: A2): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, A2, A3, R> f3(container: AssertionContainer<T>, f: KFunction4<T, A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, A2, A3, A4, R> f4(container: AssertionContainer<T>, f: KFunction5<T, A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, A2, A3, A4, A5, R> f5(container: AssertionContainer<T>, f: KFunction6<T, A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, R> manualFeature(container: AssertionContainer<T>, description: Translatable, provider: T.() -> R): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, TProperty> property(container: AssertionContainer<T>, property: KProperty1<in T, TProperty>): FeatureExtractorBuilder.ExecutionStep<T, TProperty>
interface FeatureExpect<T, R> : Expect<R>
Module Contents
operator fun <T, R> invoke(previousExpect: Expect<T>, maybeSubject: Option<R>, description: Translatable, assertions: List<Assertion>, featureExpectOptions: FeatureExpectOptions<R>): FeatureExpect<T, R>
operator fun <T, R> invoke(featureExpect: FeatureExpect<T, R>, featureExpectOptions: FeatureExpectOptions<R>): FeatureExpect<T, R>
data class FeatureExpectOptions<R>
interface FeatureExpectOptionsChooser<R>
class FeatureExpectOptionsChooserImpl<R> : FeatureExpectOptionsChooser<R>
class FeatureExtractionStepImpl<T> : FeatureExtractorBuilder.FeatureExtractionStep<T>
interface FeatureExtractor
interface FeatureExtractorBuilder
interface FeatureInfo
data class FeatureWithCreator<T, R>
abstract class FilterAtriumErrorAdjuster : AtriumErrorAdjuster
class FinalStepImpl<T> : RootExpectBuilder.FinalStep<T>
class FinalStepImpl<T, R> : FeatureExtractorBuilder.FinalStep<T, R>
class FinalStepImpl<T, R> : SubjectChangerBuilder.FinalStep<T, R>
interface FixedClaimGroup
interface FixedClaimLikeGroup
interface FloatingPointAssertions
interface FloatingPointJvmAssertions
interface Fun0Assertions
class GenericTimesCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStepInternal<T, S>, AtLeastCheckerStep<T, S>, ButAtMostCheckerStep<T, S>, ExactlyCheckerStep<T, S>
object group : Keyword
interface Group<out T>
interface HoldsStep<R>
class IgnoringCaseIndexSearcher : CharSequenceContains.Searcher<IgnoringCaseSearchBehaviour, Any>
class IgnoringCaseRegexSearcher : CharSequenceContains.Searcher<IgnoringCaseSearchBehaviour, String>
interface IgnoringCaseSearchBehaviour : CharSequenceContains.SearchBehaviour
class IgnoringCaseSearchBehaviourImpl : IgnoringCaseSearchBehaviour
class InAnyOrderEntriesAssertionCreator<E : Any, T> : ContainsAssertionCreator<T, List<E?>, (Expect<E>.() -> Unit)?, IterableLikeContains.Checker>, IterableLikeContains.Creator<T, (Expect<E>.() -> Unit)?>
abstract class InAnyOrderOnlyAssertionCreator<E, T, in SC> : IterableLikeContains.Creator<T, SC>
class InAnyOrderOnlyEntriesAssertionCreator<E : Any, T> : InAnyOrderOnlyAssertionCreator<E?, T, (Expect<E>.() -> Unit)?>
interface InAnyOrderOnlySearchBehaviour : IterableLikeContains.SearchBehaviour
interface InAnyOrderOnlySearchBehaviour : MapLikeContains.SearchBehaviour
class InAnyOrderOnlySearchBehaviourImpl : InAnyOrderOnlySearchBehaviour
class InAnyOrderOnlySearchBehaviourImpl : InAnyOrderOnlySearchBehaviour
class InAnyOrderOnlyValuesAssertionCreator<E, T> : InAnyOrderOnlyAssertionCreator<E, T, E>
interface InAnyOrderSearchBehaviour : IterableLikeContains.SearchBehaviour
interface InAnyOrderSearchBehaviour : MapLikeContains.SearchBehaviour
class InAnyOrderSearchBehaviourImpl : InAnyOrderSearchBehaviour
class InAnyOrderSearchBehaviourImpl : InAnyOrderSearchBehaviour
class InAnyOrderValuesAssertionCreator<SC, T> : ContainsObjectsAssertionCreator<T, List<SC>, SC, InAnyOrderSearchBehaviour, IterableLikeContains.Checker>, IterableLikeContains.Creator<T, SC>
class IndexSearcher : CharSequenceContains.Searcher<NoOpSearchBehaviour, Any>
data class IndexWithCreator<E>
data class InformationAssertionGroupType : ExplanatoryAssertionGroupType
abstract class InOrderOnlyAssertionCreator<E, T, SC> : InOrderOnlyBaseAssertionCreator<E, T, SC>, InOrderOnlyMatcher<E, SC>
abstract class InOrderOnlyBaseAssertionCreator<E, T, SC> : IterableLikeContains.Creator<T, SC>
class InOrderOnlyEntriesAssertionCreator<E : Any, T> : InOrderOnlyAssertionCreator<E?, T, (Expect<E>.() -> Unit)?>, InOrderOnlyMatcher<E?, (Expect<E>.() -> Unit)?>
class InOrderOnlyEntriesMatcher<E : Any> : InOrderOnlyMatcher<E?, (Expect<E>.() -> Unit)?>
abstract class InOrderOnlyGroupedAssertionCreator<E, T, SC> : InOrderOnlyBaseAssertionCreator<E, T, List<SC>>, InOrderOnlyMatcher<E, SC>
class InOrderOnlyGroupedEntriesAssertionCreator<E : Any, T> : InOrderOnlyGroupedAssertionCreator<E?, T, (Expect<E>.() -> Unit)?>, InOrderOnlyMatcher<E?, (Expect<E>.() -> Unit)?>
interface InOrderOnlyGroupedSearchBehaviour : IterableLikeContains.SearchBehaviour
class InOrderOnlyGroupedSearchBehaviourImpl : InOrderOnlyGroupedSearchBehaviour
class InOrderOnlyGroupedValuesAssertionCreator<E, T> : InOrderOnlyGroupedAssertionCreator<E, T, E>, InOrderOnlyMatcher<E, E>
interface InOrderOnlyGroupedWithinSearchBehaviour : InOrderOnlyGroupedSearchBehaviour
class InOrderOnlyGroupedWithinSearchBehaviourImpl : InOrderOnlyGroupedWithinSearchBehaviour
interface InOrderOnlyMatcher<E, SC>
interface InOrderOnlyReportingOptions
interface InOrderOnlySearchBehaviour : IterableLikeContains.SearchBehaviour
interface InOrderOnlySearchBehaviour : MapLikeContains.SearchBehaviour
class InOrderOnlySearchBehaviourImpl : InOrderOnlySearchBehaviour
class InOrderOnlySearchBehaviourImpl : InOrderOnlySearchBehaviour
class InOrderOnlyValueMatcher<E> : InOrderOnlyMatcher<E, E>
class InOrderOnlyValuesAssertionCreator<E, T> : InOrderOnlyAssertionCreator<E, T, E>, InOrderOnlyMatcher<E, E>
interface InOrderSearchBehaviour : IterableLikeContains.SearchBehaviour
interface InOrderSearchBehaviour : MapLikeContains.SearchBehaviour
class InOrderSearchBehaviourImpl : InOrderSearchBehaviour
class InOrderSearchBehaviourImpl : InOrderSearchBehaviour
object InvisibleAssertionGroupType : AssertionGroupType
sealed class IoResult<out T>
typealias IterableLike = Any
interface IterableLikeAssertions
Module Contents
abstract fun <T, E> all(container: AssertionContainer<T>, converter: (T) -> Iterable<E?>, assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Assertion
abstract fun <T, E> builderContainsInIterableLike(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>
abstract fun <T, E> builderContainsNotInIterableLike(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): NotCheckerStep<E, T, NotSearchBehaviour>
abstract fun <T, E> containsNoDuplicates(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
abstract fun <T, E> hasNext(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
abstract fun <T, E> hasNotNext(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
abstract fun <T, E : Comparable<E>> max(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): FeatureExtractorBuilder.ExecutionStep<T, E>
abstract fun <T, E : Comparable<E>> min(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): FeatureExtractorBuilder.ExecutionStep<T, E>
interface IterableLikeContains
Module Contents
interface Checker : Contains.Checker
interface CheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : Contains.CheckerStep<T, S, IterableLikeContains.Checker, IterableLikeContains.EntryPointStep<E, T, S>>
interface CheckerStepInternal<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStep<E, T, S>, IterableLikeContains.CheckerStepLogic<E, T, S>
interface CheckerStepLogic<E, T, out S : IterableLikeContains.SearchBehaviour> : Contains.CheckerStepLogic<T, S, IterableLikeContains.Checker, IterableLikeContains.EntryPointStepLogic<E, T, S>>
interface Creator<T, in SC> : Contains.Creator<T, SC>
interface EntryPointStep<E, T, out S : IterableLikeContains.SearchBehaviour> : Contains.EntryPointStep<T, S>
interface EntryPointStepInternal<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.EntryPointStep<E, T, S>, IterableLikeContains.EntryPointStepLogic<E, T, S>
interface EntryPointStepLogic<E, T, out S : IterableLikeContains.SearchBehaviour> : Contains.EntryPointStepLogic<T, S>
interface SearchBehaviour : Contains.SearchBehaviour
interface IterableLikeContainsAssertions
Module Contents
abstract fun <E : Any, T> entriesInAnyOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
abstract fun <E : Any, T> entriesInOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
abstract fun <E : Any, T> entriesInOrderOnlyGrouped(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<(Expect<E>.() -> Unit)?>>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
abstract fun <E, T> valuesInAnyOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T> valuesInOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlySearchBehaviour>, expected: List<E>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
abstract fun <E, T> valuesInOrderOnlyGrouped(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
interface IterableLikeContainsInAnyOrderAssertions
interface IterableLikeToIterableTransformer
interface IteratorAssertions
java.lang.StringBuilder
java.nio.file.Path
java.util.Locale
data class KeyValue<out K, V : Any>
class KeyValues<out K, V : Any> : VarArgHelper<KeyWithValueCreator<K, V>>
data class KeyWithCreator<out K, V>
data class KeyWithValueCreator<out K, V : Any>
interface Keyword
class KindStepImpl<T> : SubjectChangerBuilder.KindStep<T>
kotlin.reflect.KClass
kotlin.String
kotlin.Throwable
class LazyRepresentation
class LazyThreadUnsafeAssertionGroup : AssertionGroup
data class Left<L> : Either<L, Nothing>
interface ListAssertionGroupType : AssertionGroupType
interface ListAssertions
interface LocalDateAssertions
interface LocalDateTimeAssertions
data class Locale
interface LocaleOrderDecider
interface LocaleProvider
interface MapEntryAssertions
Module Contents
abstract fun <K, V, T : Entry<K, V>> isKeyValue(container: AssertionContainer<T>, key: K, value: V): Assertion
abstract fun <K, T : Entry<K, *>> key(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, K>
abstract fun <V, T : Entry<*, V>> value(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, V>
typealias MapLike = Any
interface MapLikeAssertions
Module Contents
abstract fun <T, K, V> builderContainsInMapLike(container: AssertionContainer<T>, converter: (T) -> Map<out K, V>): MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>
abstract fun <K, T> containsKey(container: AssertionContainer<T>, converter: (T) -> Map<out K, *>, key: K): Assertion
abstract fun <K, T> containsNotKey(container: AssertionContainer<T>, converter: (T) -> Map<out K, *>, key: K): Assertion
abstract fun <K, V, T> getExisting(container: AssertionContainer<T>, converter: (T) -> Map<out K, V>, key: K): FeatureExtractorBuilder.ExecutionStep<T, V>
interface MapLikeContains
Module Contents
interface Checker : Contains.Checker
interface Creator<T, in SC> : Contains.Creator<T, SC>
interface EntryPointStep<K, V, T, out S : MapLikeContains.SearchBehaviour> : Contains.EntryPointStep<T, S>
interface EntryPointStepInternal<K, V, T, out S : MapLikeContains.SearchBehaviour> : MapLikeContains.EntryPointStep<K, V, T, S>, MapLikeContains.EntryPointStepLogic<K, V, T, S>
interface EntryPointStepLogic<K, V, T, out S : MapLikeContains.SearchBehaviour> : Contains.EntryPointStepLogic<T, S>
interface SearchBehaviour : Contains.SearchBehaviour
interface MapLikeContainsAssertions
Module Contents
abstract fun <K, V, T> keyValuePairsInAnyOrder(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InAnyOrderSearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
abstract fun <K, V, T> keyValuePairsInAnyOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InAnyOrderOnlySearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
abstract fun <K, V, T> keyValuePairsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InOrderOnlySearchBehaviour>, keyValuePairs: List<Pair<K, V>>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
abstract fun <K, V : Any, T> keyWithValueAssertionsInAnyOrder(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InAnyOrderSearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
abstract fun <K, V : Any, T> keyWithValueAssertionsInAnyOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InAnyOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
abstract fun <K, V : Any, T> keyWithValueAssertionsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
abstract fun <K, V : Any, T> keyWithValueAssertionsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
interface MapLikeToIterablePairTransformer
data class MetaFeature<T>
class MetaFeatureOption<T>
Module Contents
MetaFeatureOption(expect: Expect<T>)
fun <R> f(property: KProperty0<R>): MetaFeature<R>
fun <R> f(f: KFunction0<R>): MetaFeature<R>
fun <A1, R> f(f: KFunction1<A1, R>, a1: A1): MetaFeature<R>
fun <A1, A2, R> f(f: KFunction2<A1, A2, R>, a1: A1, a2: A2): MetaFeature<R>
fun <A1, A2, A3, R> f(f: KFunction3<A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): MetaFeature<R>
fun <A1, A2, A3, A4, R> f(f: KFunction4<A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): MetaFeature<R>
fun <A1, A2, A3, A4, A5, R> f(f: KFunction5<A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): MetaFeature<R>
fun <R> f0(f: KFunction0<R>): MetaFeature<R>
fun <A1, R> f1(f: KFunction1<A1, R>, a1: A1): MetaFeature<R>
fun <A1, A2, R> f2(f: KFunction2<A1, A2, R>, a1: A1, a2: A2): MetaFeature<R>
fun <A1, A2, A3, R> f3(f: KFunction3<A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): MetaFeature<R>
fun <A1, A2, A3, A4, R> f4(f: KFunction4<A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): MetaFeature<R>
fun <A1, A2, A3, A4, A5, R> f5(f: KFunction5<A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): MetaFeature<R>
fun <R> p(property: KProperty0<R>): MetaFeature<R>
class MetaFeatureOption<T>
Module Contents
MetaFeatureOption(expect: Expect<T>)
fun <R> f(property: KProperty0<R>): MetaFeature<R>
fun <R> f(f: KFunction0<R>): MetaFeature<R>
fun <A1, R> f(f: KFunction1<A1, R>, a1: A1): MetaFeature<R>
fun <A1, A2, R> f(f: KFunction2<A1, A2, R>, a1: A1, a2: A2): MetaFeature<R>
fun <A1, A2, A3, R> f(f: KFunction3<A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): MetaFeature<R>
fun <A1, A2, A3, A4, R> f(f: KFunction4<A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): MetaFeature<R>
fun <A1, A2, A3, A4, A5, R> f(f: KFunction5<A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): MetaFeature<R>
fun <R> f0(f: KFunction0<R>): MetaFeature<R>
fun <A1, R> f1(f: KFunction1<A1, R>, a1: A1): MetaFeature<R>
fun <A1, A2, R> f2(f: KFunction2<A1, A2, R>, a1: A1, a2: A2): MetaFeature<R>
fun <A1, A2, A3, R> f3(f: KFunction3<A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): MetaFeature<R>
fun <A1, A2, A3, A4, R> f4(f: KFunction4<A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): MetaFeature<R>
fun <A1, A2, A3, A4, A5, R> f5(f: KFunction5<A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): MetaFeature<R>
fun <R> p(property: KProperty0<R>): MetaFeature<R>
data class MetaFeatureOptionWithCreator<T, R>
interface MethodCallFormatter
expect class MultiAtriumErrorAdjuster : AtriumErrorAdjuster
object next : Keyword
object noDuplicates : Keyword
object None : Option<Nothing>
expect object NoOpAtriumErrorAdjuster : AtriumErrorAdjuster
abstract class NoOpAtriumErrorAdjusterCommon : AtriumErrorAdjuster
class NoOpCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStepInternal<E, T, S>
interface NoOpSearchBehaviour : CharSequenceContains.SearchBehaviour
interface NoOpSearchBehaviour : IterableLikeContains.SearchBehaviour
interface NoOpSearchBehaviour : MapLikeContains.SearchBehaviour
class NoOpSearchBehaviourImpl : NoOpSearchBehaviour
class NoOpSearchBehaviourImpl : NoOpSearchBehaviour
class NoOpSearchBehaviourImpl : NoOpSearchBehaviour
abstract class NoSpecialChildFormattingSingleAssertionGroupTypeFormatter<in T : AssertionGroupType> : SingleAssertionGroupTypeFormatter<T>
interface NotChecker : CharSequenceContains.Checker
interface NotChecker : NotChecker, CharSequenceContains.Checker
interface NotChecker : NotChecker, IterableLikeContains.Checker
interface NotChecker : NotChecker, MapLikeContains.Checker
interface NotCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStep<T, S>
interface NotCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStep<E, T, S>
class NotCheckerStepImpl<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotCheckerStep<T, S>, CharSequenceContains.CheckerStepInternal<T, S>
interface NotOrAtMostCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStep<T, S>
interface NotOrAtMostCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStep<E, T, S>
class NotOrAtMostCheckerStepImpl<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotOrAtMostCheckerStep<T, S>, CharSequenceContains.CheckerStepInternal<T, S>
interface NotSearchBehaviour : NoOpSearchBehaviour
interface NotSearchBehaviour : InAnyOrderSearchBehaviour
class NotSearchBehaviourImpl : NotSearchBehaviour
class NotSearchBehaviourImpl : NotSearchBehaviour
object o : Keyword
interface ObjectFormatter
object only : Keyword
class OnlyFailureReporter : Reporter
sealed class Option<out T>
interface OptionalAssertions
class OptionsStepImpl<T> : RootExpectBuilder.OptionsStep<T>
class OptionsStepImpl<T, R> : FeatureExtractorBuilder.OptionsStep<T, R>
object order : Keyword
class Order<out T, out G : Group<T>>
interface PairAssertions
class Pairs<out K, out V> : VarArgHelper<Pair<K, V>>
interface PartiallyFixedClaimGroup
interface PathAssertions
Module Contents
abstract fun <T : Path> endsNotWith(container: AssertionContainer<T>, expected: Path): Assertion
abstract fun <T : Path> endsWith(container: AssertionContainer<T>, expected: Path): Assertion
abstract fun <T : Path> exists(container: AssertionContainer<T>, linkOption: LinkOption? = null): Assertion
abstract fun <T : Path> existsNot(container: AssertionContainer<T>, linkOption: LinkOption? = null): Assertion
abstract fun <T : Path> extension(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
abstract fun <T : Path> fileName(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
abstract fun <T : Path> fileNameWithoutExtension(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
abstract fun <T : Path> hasDirectoryEntry(container: AssertionContainer<T>, entries: List<String>): Assertion
abstract fun <T : Path> hasSameBinaryContentAs(container: AssertionContainer<T>, targetPath: Path): Assertion
abstract fun <T : Path> hasSameTextualContentAs(container: AssertionContainer<T>, targetPath: Path, sourceCharset: Charset, targetCharset: Charset): Assertion
abstract fun <T : Path> isAbsolute(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isDirectory(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isEmptyDirectory(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isExecutable(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isNotExecutable(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isNotReadable(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isNotWritable(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isReadable(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isRegularFile(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isRelative(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isSymbolicLink(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isWritable(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> parent(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, Path>
abstract fun <T : Path> resolve(container: AssertionContainer<T>, other: String): FeatureExtractorBuilder.ExecutionStep<T, Path>
abstract fun <T : Path> startsNotWith(container: AssertionContainer<T>, expected: Path): Assertion
abstract fun <T : Path> startsWith(container: AssertionContainer<T>, expected: Path): Assertion
data class PathWithCreator<E>
data class PathWithEncoding
class PleaseUseReplacementException : Exception
class PrefixFailingSummaryAssertion : BulletPointIdentifier
class PrefixFeatureAssertionGroupHeader : BulletPointIdentifier
class PrefixSuccessfulSummaryAssertion : BulletPointIdentifier
object present : Keyword
data class PresentWithCreator<E>
abstract class PropertiesBasedTranslationSupplier<in T> : TranslationSupplier
class PropertiesPerEntityAndLocaleTranslationSupplier : PropertiesBasedTranslationSupplier<String>
class PropertiesPerLocaleTranslationSupplier : PropertiesBasedTranslationSupplier<Locale>
object readable : Keyword
class RegexPatterns : VarArgHelper<String>
class RegexSearcher : CharSequenceContains.Searcher<NoOpSearchBehaviour, Regex>
object relative : Keyword
interface RemoveAtriumFromAtriumError : AtriumErrorAdjuster
expect class RemoveAtriumFromAtriumErrorImpl : RemoveAtriumFromAtriumError
interface RemoveRunnerFromAtriumError : AtriumErrorAdjuster
expect class RemoveRunnerFromAtriumErrorImpl : RemoveRunnerFromAtriumError
interface Reporter
interface RepresentationOnly
interface RepresentationOnlyAssertion : Assertion
object ResourceBundleInspiredLocaleOrderDecider : LocaleOrderDecider
interface ResultAssertions
data class Right<R> : Either<Nothing, R>
object RootAssertionGroupType : AssertionGroupType
interface RootExpect<T> : Expect<T>
interface RootExpectBuilder
data class RootExpectOptions<T>
class RootExpectOptionsChooserImpl<T> : RootExpectBuilder.OptionsChooser<T>
abstract class SingleAssertionGroupTypeFormatter<in T : AssertionGroupType> : AssertionFormatter
data class Some<T> : Option<T>
expect class StackTraceBasedFeatureInfo : FeatureInfo
interface StringBasedTranslatable : Translatable
interface SubjectBasedOption
Module Contents
interface AbsentOption<T, R>
interface DefinedOption<T, R, AO : SubjectBasedOption.AbsentOption<T, R>>
operator fun <T, R, PO : SubjectBasedOption.DefinedOption<T, R, *>> invoke(expect: Expect<T>, subStep: PO.() -> Pair<() -> R, (T) -> R>, presentOptionFactory: () -> PO): R
interface SubjectChanger
Module Contents
interface FailureHandler<T, R>
abstract fun <T, R> reported(container: AssertionContainer<T>, description: Translatable, representation: Any, transformation: (T) -> Option<R>, failureHandler: SubjectChanger.FailureHandler<T, R>, maybeSubAssertions: Option<Expect<R>.() -> Unit>): Expect<R>
abstract fun <T, R> unreported(container: AssertionContainer<T>, transformation: (T) -> R): Expect<R>
interface SubjectChangerBuilder
Module Contents
interface DescriptionRepresentationStep<T>
interface ExecutionStep<T, R> : TransformationExecutionStep<T, R, Expect<R>>
interface FailureHandlerStep<T, R>
Module Contents
open fun build(): SubjectChangerBuilder.ExecutionStep<T, R>
operator fun <T, R> invoke(transformationStep: SubjectChangerBuilder.TransformationStep<T>, transformation: (T) -> Option<R>): SubjectChangerBuilder.FailureHandlerStep<T, R>
abstract val transformation: (T) -> Option<R>
abstract val transformationStep: SubjectChangerBuilder.TransformationStep<T>
abstract fun withDefaultFailureHandler(): SubjectChangerBuilder.FinalStep<T, R>
abstract fun withFailureHandler(failureHandler: SubjectChanger.FailureHandler<T, R>): SubjectChangerBuilder.FinalStep<T, R>
open fun <R1> withFailureHandlerAdapter(failureHandler: SubjectChanger.FailureHandler<R1, R>, map: (T) -> R1): SubjectChangerBuilder.FinalStep<T, R>
interface FinalStep<T, R>
operator fun <T> invoke(container: AssertionContainer<T>): SubjectChangerBuilder.KindStep<T>
interface KindStep<T>
interface TransformationStep<T>
interface SubjectProvider<out T>
object success : Keyword
class Success<out T> : IoResult<T>
data class SuccessWithCreator<E>
interface SummaryAssertionGroupType : DoNotFilterAssertionGroupType
data class Text
interface TextAssertionFormatter : AssertionFormatter
interface TextAssertionFormatterFactory
interface TextAssertionPairFormatter : AssertionPairFormatter
class TextExplanatoryAssertionGroupFormatter : NoSpecialChildFormattingSingleAssertionGroupTypeFormatter<ExplanatoryAssertionGroupType>, TextAssertionFormatter
class TextFallbackAssertionFormatter : AssertionFormatter, TextAssertionFormatter
class TextFeatureAssertionGroupFormatter : NoSpecialChildFormattingSingleAssertionGroupTypeFormatter<FeatureAssertionGroupType>, TextAssertionFormatter
class TextListAssertionGroupFormatter : TextListBasedAssertionGroupFormatter<ListAssertionGroupType>
abstract class TextListBasedAssertionGroupFormatter<in T : AssertionGroupType> : NoSpecialChildFormattingSingleAssertionGroupTypeFormatter<T>, TextAssertionFormatter
interface TextMethodCallFormatter : MethodCallFormatter
class TextNextLineAssertionPairFormatter : AssertionPairFormatter, TextAssertionPairFormatter
interface TextObjectFormatter : ObjectFormatter
abstract class TextObjectFormatterCommon : TextObjectFormatter
class TextPrefixBasedAssertionGroupFormatter
class TextSameLineAssertionPairFormatter : AssertionPairFormatter, TextAssertionPairFormatter
class TextSummaryAssertionGroupFormatter : SingleAssertionGroupTypeFormatter<SummaryAssertionGroupType>, TextAssertionFormatter
interface ThrowableAssertions
class ThrowableThrownFailureHandler<T : Throwable?, R> : SubjectChanger.FailureHandler<T, R>
interface TransformationExecutionStep<T, R, E : Expect<R>>
class TransformationStepImpl<T> : SubjectChangerBuilder.TransformationStep<T>
interface Translatable
data class TranslatableWithArgs : Translatable
interface TranslationSupplier
class TranslationSupplierBasedTranslator : ArgumentsSupportingTranslator
interface Translator
class Untranslatable : Translatable
object UseDefaultLocaleAsPrimary : LocaleProvider
object UsingDefaultBulletPoints : BulletPointProvider
class UsingDefaultTranslator : ArgumentsSupportingTranslator
data class Value<out T> : Group<T>
data class Value<T> : Group<T>
class Values<out T> : Group<T>, VarArgHelper<T>
class Values<out T> : Group<T>, VarArgHelper<T>
interface VarArgHelper<out T>
object WarningAssertionGroupType : ExplanatoryAssertionGroupType
interface WithTimesChecker : Contains.Checker
interface WithTimesCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStep<T, S>
interface WithTimesCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStep<E, T, S>
interface WithTimesCheckerStepInternal<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>, WithTimesCheckerStepLogic<T, S>, CharSequenceContains.CheckerStepInternal<T, S>
interface WithTimesCheckerStepInternal<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>, WithTimesCheckerStepLogic<E, T, S>, IterableLikeContains.CheckerStepInternal<E, T, S>
interface WithTimesCheckerStepLogic<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStepLogic<T, S>
interface WithTimesCheckerStepLogic<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStepLogic<E, T, S>
object writable : Keyword
interface ZonedDateTimeAssertions
package ch.tutteli.atrium.api.fluent.en_GB
Module Contents
fun <E : Any, T : Iterable<E?>> Expect<T>.all(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
inline val <T> Expect<T>.and: Expect<T>
infix fun <T> Expect<T>.and(assertionCreator: Expect<T>.() -> Unit): Expect<T>
fun <E : Any, T : Iterable<E?>> Expect<T>.any(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <K, V, T : Map<out K, V>> Expect<T>.asEntries(): Expect<Set<Entry<K, V>>>
fun <K, V, T : Map<out K, V>> Expect<T>.asEntries(assertionCreator: Expect<Set<Entry<K, V>>>.() -> Unit): Expect<T>
fun <E, T : Sequence<E>> Expect<T>.asIterable(): Expect<Iterable<E>>
fun <E, T : Sequence<E>> Expect<T>.asIterable(assertionCreator: Expect<Iterable<E>>.() -> Unit): Expect<T>
fun <E> Expect<out Array<out E>>.asList(): Expect<List<E>>
fun <E> Expect<Array<E>>.asList(assertionCreator: Expect<List<E>>.() -> Unit): Expect<Array<E>>
@JvmName("byteArrAsList") fun Expect<ByteArray>.asList(): Expect<List<Byte>>
@JvmName("byteArrAsList") fun Expect<ByteArray>.asList(assertionCreator: Expect<List<Byte>>.() -> Unit): Expect<ByteArray>
@JvmName("charArrAsList") fun Expect<CharArray>.asList(): Expect<List<Char>>
@JvmName("charArrAsList") fun Expect<CharArray>.asList(assertionCreator: Expect<List<Char>>.() -> Unit): Expect<CharArray>
@JvmName("shortArrAsList") fun Expect<ShortArray>.asList(): Expect<List<Short>>
@JvmName("shortArrAsList") fun Expect<ShortArray>.asList(assertionCreator: Expect<List<Short>>.() -> Unit): Expect<ShortArray>
@JvmName("intArrAsList") fun Expect<IntArray>.asList(): Expect<List<Int>>
@JvmName("intArrAsList") fun Expect<IntArray>.asList(assertionCreator: Expect<List<Int>>.() -> Unit): Expect<IntArray>
@JvmName("longArrAsList") fun Expect<LongArray>.asList(): Expect<List<Long>>
@JvmName("longArrAsList") fun Expect<LongArray>.asList(assertionCreator: Expect<List<Long>>.() -> Unit): Expect<LongArray>
@JvmName("floatArrAsList") fun Expect<FloatArray>.asList(): Expect<List<Float>>
@JvmName("floatArrAsList") fun Expect<FloatArray>.asList(assertionCreator: Expect<List<Float>>.() -> Unit): Expect<FloatArray>
@JvmName("doubleArrAsList") fun Expect<DoubleArray>.asList(): Expect<List<Double>>
@JvmName("doubleArrAsList") fun Expect<DoubleArray>.asList(assertionCreator: Expect<List<Double>>.() -> Unit): Expect<DoubleArray>
@JvmName("boolArrAsList") fun Expect<BooleanArray>.asList(): Expect<List<Boolean>>
@JvmName("boolArrAsList") fun Expect<BooleanArray>.asList(assertionCreator: Expect<List<Boolean>>.() -> Unit): Expect<BooleanArray>
fun <E, T : Iterable<E>> Expect<T>.asList(): Expect<List<E>>
fun <E, T : Iterable<E>> Expect<T>.asList(assertionCreator: Expect<List<E>>.() -> Unit): Expect<T>
fun <T : File> Expect<T>.asPath(): Expect<Path>
fun <T : File> Expect<T>.asPath(assertionCreator: Expect<Path>.() -> Unit): Expect<T>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.atLeast(times: Int): AtLeastCheckerStep<T, S>
fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.atLeast(times: Int): AtLeastCheckerStep<E, T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.atMost(times: Int): AtMostCheckerStep<T, S>
fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.atMost(times: Int): AtMostCheckerStep<E, T, S>
fun <T> Expect<T>.because(reason: String, assertionCreator: Expect<T>.() -> Unit): Expect<T>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> AtLeastCheckerStep<T, S>.butAtMost(times: Int): ButAtMostCheckerStep<T, S>
fun <E, T, S : InAnyOrderSearchBehaviour> AtLeastCheckerStep<E, T, S>.butAtMost(times: Int): ButAtMostCheckerStep<E, T, S>
inline fun <reified TExpected : Throwable> Expect<out Throwable>.cause(): Expect<TExpected>
inline fun <reified TExpected : Throwable> Expect<out Throwable>.cause(noinline assertionCreator: Expect<TExpected>.() -> Unit): Expect<TExpected>
val <T : CharSequence> Expect<T>.contains: CharSequenceContains.EntryPointStep<T, NoOpSearchBehaviour>
fun <T : CharSequence> Expect<T>.contains(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>
fun <E, T : Iterable<E>> Expect<T>.contains(expected: E, vararg otherExpected: E): Expect<T>
fun <E : Any, T : Iterable<E?>> Expect<T>.contains(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T : Iterable<E?>> Expect<T>.contains(assertionCreatorOrNull: (Expect<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<E>.() -> Unit)?): Expect<T>
fun <K, V, T : Map<out K, V>> Expect<T>.contains(keyValuePair: Pair<K, V>, vararg otherPairs: Pair<K, V>): Expect<T>
inline fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.contains(keyValue: KeyValue<K, V>, vararg otherKeyValues: KeyValue<K, V>): Expect<T>
inline fun <reified E, T : Iterable<E>> Expect<T>.containsElementsOf(expectedIterableLike: IterableLike): Expect<T>
fun <K, V : Any, T : Map<out K, V?>> Expect<T>.containsEntriesOf(mapLike: MapLike): Expect<T>
fun <E, T : Iterable<E>> Expect<T>.containsExactly(expected: E, vararg otherExpected: E): Expect<T>
fun <E : Any, T : Iterable<E?>> Expect<T>.containsExactly(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T : Iterable<E?>> Expect<T>.containsExactly(assertionCreatorOrNull: (Expect<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<E>.() -> Unit)?): Expect<T>
inline fun <reified E, T : Iterable<E>> Expect<T>.containsExactlyElementsOf(expectedIterableLike: IterableLike): Expect<T>
fun <K, T : Map<out K, *>> Expect<T>.containsKey(key: K): Expect<T>
fun <E, T : Iterable<E>> Expect<T>.containsNoDuplicates(): Expect<T>
val <T : CharSequence> Expect<T>.containsNot: NotCheckerStep<T, NotSearchBehaviour>
fun <T : CharSequence> Expect<T>.containsNot(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>
fun <E, T : Iterable<E>> Expect<T>.containsNot(expected: E, vararg otherExpected: E): Expect<T>
fun <K, T : Map<out K, *>> Expect<T>.containsNotKey(key: K): Expect<T>
fun <K, V, T : Map<out K, V>> Expect<T>.containsOnly(keyValuePair: Pair<K, V>, vararg otherPairs: Pair<K, V>): Expect<T>
inline fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.containsOnly(keyValue: KeyValue<K, V>, vararg otherKeyValues: KeyValue<K, V>): Expect<T>
fun <K, V : Any, T : Map<out K, V?>> Expect<T>.containsOnlyEntriesOf(mapLike: MapLike): Expect<T>
fun <T : CharSequence> Expect<T>.containsRegex(pattern: String, vararg otherPatterns: String): Expect<T>
fun <T : CharSequence> Expect<T>.containsRegex(pattern: Regex, vararg otherPatterns: Regex): Expect<T>
val Expect<LocalDate>.day: Expect<Int>
val Expect<LocalDateTime>.day: Expect<Int>
val Expect<ZonedDateTime>.day: Expect<Int>
fun Expect<LocalDate>.day(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDate>
fun Expect<LocalDateTime>.day(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDateTime>
fun Expect<ZonedDateTime>.day(assertionCreator: Expect<Int>.() -> Unit): Expect<ZonedDateTime>
val Expect<LocalDate>.dayOfWeek: Expect<DayOfWeek>
val Expect<LocalDateTime>.dayOfWeek: Expect<DayOfWeek>
val Expect<ZonedDateTime>.dayOfWeek: Expect<DayOfWeek>
fun Expect<LocalDate>.dayOfWeek(assertionCreator: Expect<DayOfWeek>.() -> Unit): Expect<LocalDate>
fun Expect<LocalDateTime>.dayOfWeek(assertionCreator: Expect<DayOfWeek>.() -> Unit): Expect<LocalDateTime>
fun Expect<ZonedDateTime>.dayOfWeek(assertionCreator: Expect<DayOfWeek>.() -> Unit): Expect<ZonedDateTime>
fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
@JvmName("elementsOfIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
@JvmName("elementsOfIgnoringCase") fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
inline fun <reified E, T> IterableLikeContains.CheckerStep<E, T, InAnyOrderSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
inline fun <reified E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
inline fun <reified E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
fun <T : CharSequence> Expect<T>.endsNotWith(expected: CharSequence): Expect<T>
fun <T : CharSequence> Expect<T>.endsNotWith(expected: Char): Expect<T>
fun <T : Path> Expect<T>.endsNotWith(expected: Path): Expect<T>
fun <T : CharSequence> Expect<T>.endsWith(expected: CharSequence): Expect<T>
fun <T : CharSequence> Expect<T>.endsWith(expected: Char): Expect<T>
fun <T : Path> Expect<T>.endsWith(expected: Path): Expect<T>
fun <E : Any, T> IterableLikeContains.CheckerStep<out E?, T, InAnyOrderSearchBehaviour>.entries(assertionCreatorOrNull: (Expect<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InAnyOrderOnlySearchBehaviour>.entries(assertionCreatorOrNull: (Expect<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlySearchBehaviour>.entries(assertionCreatorOrNull: (Expect<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<E>.() -> Unit)?): Expect<T>
fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.entries(keyValuePair: Pair<K, V>, vararg otherPairs: Pair<K, V>): Expect<T>
inline fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderSearchBehaviour>.entries(keyValue: KeyValue<K, V>, vararg otherKeyValues: KeyValue<K, V>): Expect<T>
fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>.entries(keyValuePair: Pair<K, V>, vararg otherPairs: Pair<K, V>): Expect<T>
inline fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderOnlySearchBehaviour>.entries(keyValue: KeyValue<K, V>, vararg otherKeyValues: KeyValue<K, V>): Expect<T>
fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>.entries(keyValuePair: Pair<K, V>, vararg otherPairs: Pair<K, V>): Expect<T>
inline fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InOrderOnlySearchBehaviour>.entries(keyValue: KeyValue<K, V>, vararg otherKeyValues: KeyValue<K, V>): Expect<T>
class Entries<T : Any> : Group<(Expect<T>.() -> Unit)?>, VarArgHelper<(Expect<T>.() -> Unit)?>
fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.entriesOf(expectedMapLike: MapLike): Expect<T>
fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>.entriesOf(expectedMapLike: MapLike): Expect<T>
fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>.entriesOf(expectedMapLike: MapLike): Expect<T>
fun <E : Any, T> IterableLikeContains.CheckerStep<out E?, T, InAnyOrderSearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.entry(keyValuePair: Pair<K, V>): Expect<T>
inline fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderSearchBehaviour>.entry(keyValue: KeyValue<K, V>): Expect<T>
fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>.entry(keyValuePair: Pair<K, V>): Expect<T>
inline fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderOnlySearchBehaviour>.entry(keyValue: KeyValue<K, V>): Expect<T>
fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>.entry(keyValuePair: Pair<K, V>): Expect<T>
inline fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InOrderOnlySearchBehaviour>.entry(keyValue: KeyValue<K, V>): Expect<T>
class Entry<T : Any> : Group<(Expect<T>.() -> Unit)?>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.exactly(times: Int): ExactlyCheckerStep<T, S>
fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.exactly(times: Int): ExactlyCheckerStep<E, T, S>
fun <T : Path> Expect<T>.exists(): Expect<T>
fun <T : Path> Expect<T>.existsNot(): Expect<T>
@Target([AnnotationTarget.FUNCTION]) annotation class ExperimentalWithOptions
val <T : Path> Expect<T>.extension: Expect<String>
fun <T : Path> Expect<T>.extension(assertionCreator: Expect<String>.() -> Unit): Expect<T>
fun <T, R> Expect<T>.feature(property: KProperty1<in T, R>): FeatureExpect<T, R>
fun <T, R> Expect<T>.feature(property: KProperty1<in T, R>, assertionCreator: Expect<R>.() -> Unit): Expect<T>
fun <T, R> Expect<T>.feature(f: KFunction1<T, R>): FeatureExpect<T, R>
fun <T, R> Expect<T>.feature(f: KFunction1<T, R>, assertionCreator: Expect<R>.() -> Unit): Expect<T>
fun <T, A1, R> Expect<T>.feature(f: KFunction2<T, A1, R>, a1: A1): FeatureExpect<T, R>
fun <T, A1, R> Expect<T>.feature(f: KFunction2<T, A1, R>, a1: A1, assertionCreator: Expect<R>.() -> Unit): Expect<T>
fun <T, A1, A2, R> Expect<T>.feature(f: KFunction3<T, A1, A2, R>, a1: A1, a2: A2): FeatureExpect<T, R>
fun <T, A1, A2, R> Expect<T>.feature(f: KFunction3<T, A1, A2, R>, a1: A1, a2: A2, assertionCreator: Expect<R>.() -> Unit): Expect<T>
fun <T, A1, A2, A3, R> Expect<T>.feature(f: KFunction4<T, A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): FeatureExpect<T, R>
fun <T, A1, A2, A3, R> Expect<T>.feature(f: KFunction4<T, A1, A2, A3, R>, a1: A1, a2: A2, a3: A3, assertionCreator: Expect<R>.() -> Unit): Expect<T>
fun <T, A1, A2, A3, A4, R> Expect<T>.feature(f: KFunction5<T, A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): FeatureExpect<T, R>
fun <T, A1, A2, A3, A4, R> Expect<T>.feature(f: KFunction5<T, A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4, assertionCreator: Expect<R>.() -> Unit): Expect<T>
fun <T, A1, A2, A3, A4, A5, R> Expect<T>.feature(f: KFunction6<T, A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): FeatureExpect<T, R>
fun <T, A1, A2, A3, A4, A5, R> Expect<T>.feature(f: KFunction6<T, A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, assertionCreator: Expect<R>.() -> Unit): Expect<T>
fun <T, R> Expect<T>.feature(description: String, provider: T.() -> R): FeatureExpect<T, R>
fun <T, R> Expect<T>.feature(description: String, provider: T.() -> R, assertionCreator: Expect<R>.() -> Unit): Expect<T>
fun <T, R> Expect<T>.feature(provider: MetaFeatureOption<T>.(T) -> MetaFeature<R>): FeatureExpect<T, R>
fun <T, R> Expect<T>.feature(provider: MetaFeatureOption<T>.(T) -> MetaFeature<R>, assertionCreator: Expect<R>.() -> Unit): Expect<T>
val <T : Path> Expect<T>.fileName: Expect<String>
fun <T : Path> Expect<T>.fileName(assertionCreator: Expect<String>.() -> Unit): Expect<T>
val <T : Path> Expect<T>.fileNameWithoutExtension: Expect<String>
fun <T : Path> Expect<T>.fileNameWithoutExtension(assertionCreator: Expect<String>.() -> Unit): Expect<T>
val <K, T : Pair<K, *>> Expect<T>.first: Expect<K>
fun <K, V, T : Pair<K, V>> Expect<T>.first(assertionCreator: Expect<K>.() -> Unit): Expect<T>
fun <E, T : List<E>> Expect<T>.get(index: Int): Expect<E>
fun <E, T : List<E>> Expect<T>.get(index: Int, assertionCreator: Expect<E>.() -> Unit): Expect<T>
fun <K, V, T : Map<out K, V>> Expect<T>.getExisting(key: K): Expect<V>
fun <K, V, T : Map<out K, V>> Expect<T>.getExisting(key: K, assertionCreator: Expect<V>.() -> Unit): Expect<T>
val <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.grouped: IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedSearchBehaviour>
fun <T : Path> Expect<T>.hasDirectoryEntry(entry: String, vararg otherEntries: String): Expect<T>
fun <E, T : Iterable<E>> Expect<T>.hasNext(): Expect<T>
fun <E, T : Iterable<E>> Expect<T>.hasNotNext(): Expect<T>
fun <T : Path> Expect<T>.hasSameBinaryContentAs(targetPath: Path): Expect<T>
fun <T : Path> Expect<T>.hasSameTextualContentAs(targetPath: Path, sourceCharset: Charset = Charsets.UTF_8, targetCharset: Charset = Charsets.UTF_8): Expect<T>
fun <T : Collection<*>> Expect<T>.hasSize(expected: Int): Expect<T>
val <T : CharSequence> CharSequenceContains.EntryPointStep<T, NoOpSearchBehaviour>.ignoringCase: CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>
val <T : CharSequence> NotCheckerStep<T, NotSearchBehaviour>.ignoringCase: NotCheckerStep<T, IgnoringCaseSearchBehaviour>
fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: Group<E>, secondGroup: Group<E>, vararg otherExpectedGroups: Group<E>): Expect<T>
@JvmName("inAnyOrderEntries") fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: Group<(Expect<E>.() -> Unit)?>, secondGroup: Group<(Expect<E>.() -> Unit)?>, vararg otherExpectedGroups: Group<(Expect<E>.() -> Unit)?>): Expect<T>
val <E, T> IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>.inAnyOrder: IterableLikeContains.EntryPointStep<E, T, InAnyOrderSearchBehaviour>
val <K, V, T> MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>.inAnyOrder: MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>
val <E, T> IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>.inOrder: IterableLikeContains.EntryPointStep<E, T, InOrderSearchBehaviour>
val <K, V, T> MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>.inOrder: MapLikeContains.EntryPointStep<K, V, T, InOrderSearchBehaviour>
inline fun <reified TSub : Any> Expect<*>.isA(): Expect<TSub>
inline fun <reified TSub : Any> Expect<*>.isA(noinline assertionCreator: Expect<TSub>.() -> Unit): Expect<TSub>
fun <T : Path> Expect<T>.isAbsolute(): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isAfter(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isAfter(expected: String): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isAfter(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isAfter(expected: ChronoZonedDateTime<*>): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isAfterOrEqual(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isAfterOrEqual(expected: String): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isAfterOrEqual(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isAfterOrEqual(expected: ChronoZonedDateTime<*>): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isBefore(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isBefore(expected: String): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isBefore(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isBefore(expected: ChronoZonedDateTime<*>): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isBeforeOrEqual(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isBeforeOrEqual(expected: String): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isBeforeOrEqual(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isBeforeOrEqual(expected: ChronoZonedDateTime<*>): Expect<T>
fun <T : Path> Expect<T>.isDirectory(): Expect<T>
fun <T : CharSequence> Expect<T>.isEmpty(): Expect<T>
fun <T : Path> Expect<T>.isEmptyDirectory(): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isEqual(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isEqual(expected: String): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isEqual(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isEqual(expected: ChronoZonedDateTime<*>): Expect<T>
fun <T : Comparable<T>> Expect<T>.isEqualComparingTo(expected: T): Expect<T>
fun <T : BigDecimal> Expect<T>.isEqualIncludingScale(expected: T): Expect<T>
fun <T : Path> Expect<T>.isExecutable(): Expect<T>
fun <T : Comparable<T>> Expect<T>.isGreaterThan(expected: T): Expect<T>
fun <T : Comparable<T>> Expect<T>.isGreaterThanOrEqual(expected: T): Expect<T>
fun <K, V, T : Entry<K, V>> Expect<T>.isKeyValue(key: K, value: V): Expect<T>
fun <T : Comparable<T>> Expect<T>.isLessThan(expected: T): Expect<T>
fun <T : Comparable<T>> Expect<T>.isLessThanOrEqual(expected: T): Expect<T>
fun <T> Expect<T>.isNoneOf(expected: T, vararg otherValues: T): Expect<T>
fun <T : CharSequence> Expect<T>.isNotBlank(): Expect<T>
fun <T : CharSequence> Expect<T>.isNotEmpty(): Expect<T>
fun <T : BigDecimal> Expect<T>.isNotEqualIncludingScale(expected: T): Expect<T>
fun <T> Expect<T>.isNotIn(expected: IterableLike): Expect<T>
fun <T : BigDecimal> Expect<T>.isNotNumericallyEqualTo(expected: T): Expect<T>
fun <T> Expect<T>.isNotSameAs(expected: T): Expect<T>
fun <T : BigDecimal> Expect<T>.isNumericallyEqualTo(expected: T): Expect<T>
fun <E, T : Optional<E>> Expect<T>.isPresent(): Expect<E>
fun <E, T : Optional<E>> Expect<T>.isPresent(assertionCreator: Expect<E>.() -> Unit): Expect<T>
fun <T : Path> Expect<T>.isReadable(): Expect<T>
fun <T : Path> Expect<T>.isRegularFile(): Expect<T>
fun <T : Path> Expect<T>.isRelative(): Expect<T>
fun <T> Expect<T>.isSameAs(expected: T): Expect<T>
fun <T : Path> Expect<T>.isSymbolicLink(): Expect<T>
fun <T : Path> Expect<T>.isWritable(): Expect<T>
fun <T, R> Expect<T>.its(: T.() -> R): FeatureExpect<T, R>
fun <T, R> Expect<T>.its(: T.() -> R, assertionCreator: Expect<R>.() -> Unit): Expect<T>
val <K, T : Entry<K, *>> Expect<T>.key: Expect<K>
fun <K, V, T : Entry<K, V>> Expect<T>.key(assertionCreator: Expect<K>.() -> Unit): Expect<T>
val <K, T : Map<out K, *>> Expect<T>.keys: Expect<Set<K>>
fun <K, V, T : Map<out K, V>> Expect<T>.keys(assertionCreator: Expect<Set<K>>.() -> Unit): Expect<T>
data class KeyValue<out K, V : Any>
fun <T : CharSequence> Expect<T>.matches(expected: Regex): Expect<T>
fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.max(): Expect<E>
fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.max(assertionCreator: Expect<E>.() -> Unit): Expect<T>
val <T : Throwable> Expect<T>.message: Expect<String>
fun <T : Throwable> Expect<T>.message(assertionCreator: Expect<String>.() -> Unit): Expect<T>
fun <T : Throwable> Expect<T>.messageContains(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>
fun <T : Throwable> Expect<T>.messageToContain(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>
fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.min(): Expect<E>
fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.min(assertionCreator: Expect<E>.() -> Unit): Expect<T>
fun <T : CharSequence> Expect<T>.mismatches(expected: Regex): Expect<T>
val Expect<LocalDate>.month: Expect<Int>
val Expect<LocalDateTime>.month: Expect<Int>
val Expect<ZonedDateTime>.month: Expect<Int>
fun Expect<LocalDate>.month(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDate>
fun Expect<LocalDateTime>.month(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDateTime>
fun Expect<ZonedDateTime>.month(assertionCreator: Expect<Int>.() -> Unit): Expect<ZonedDateTime>
fun <E : Any, T : Iterable<E?>> Expect<T>.none(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerStep<T, S>
fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerStep<E, T, S>
fun <T> Expect<T>.notToBe(expected: T): Expect<T>
fun <T : CharSequence> Expect<T>.notToBeBlank(): Expect<T>
fun <T : CharSequence> Expect<T>.notToBeEmpty(): Expect<T>
fun <T : Path> Expect<T>.notToBeExecutable(): Expect<T>
fun <T : Comparable<T>> Expect<T>.notToBeGreaterThan(expected: T): Expect<T>
fun <T : Comparable<T>> Expect<T>.notToBeLessThan(expected: T): Expect<T>
inline fun <reified T : Any> Expect<T?>.notToBeNull(): Expect<T>
inline fun <reified T : Any> Expect<T?>.notToBeNull(noinline assertionCreator: Expect<T>.() -> Unit): Expect<T>
fun <T : Path> Expect<T>.notToBeReadable(): Expect<T>
fun <T> Expect<T>.notToBeTheInstance(expected: T): Expect<T>
fun <T : Path> Expect<T>.notToBeWritable(): Expect<T>
val <T : CharSequence> Expect<T>.notToContain: NotCheckerStep<T, NotSearchBehaviour>
fun <T : CharSequence> Expect<T>.notToContain(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>
fun <E, T : Iterable<E>> Expect<T>.notToContain(expected: E, vararg otherExpected: E): Expect<T>
fun <K, T : Map<out K, *>> Expect<T>.notToContainKey(key: K): Expect<T>
fun <T : CharSequence> Expect<T>.notToEndWith(expected: CharSequence): Expect<T>
fun <T : Path> Expect<T>.notToEndWith(expected: Path): Expect<T>
fun <T> Expect<T>.notToEqual(expected: T): Expect<T>
fun <T : BigDecimal> Expect<T>.notToEqualIncludingScale(expected: T): Expect<T>
inline fun <reified T : Any> Expect<T?>.notToEqualNull(): Expect<T>
inline fun <reified T : Any> Expect<T?>.notToEqualNull(noinline assertionCreator: Expect<T>.() -> Unit): Expect<T>
fun <T : BigDecimal> Expect<T>.notToEqualNumerically(expected: T): Expect<T>
fun <T> Expect<T>.notToEqualOneIn(expected: IterableLike): Expect<T>
fun <T> Expect<T>.notToEqualOneOf(expected: T, vararg otherValues: T): Expect<T>
fun <T : Path> Expect<T>.notToExist(): Expect<T>
fun <E, T : Iterable<E>> Expect<T>.notToHaveElements(): Expect<T>
fun <T : Iterator<*>> Expect<T>.notToHaveNext(): Expect<T>
fun <T : CharSequence> Expect<T>.notToMatch(pattern: Regex): Expect<T>
fun <T : CharSequence> Expect<T>.notToStartWith(expected: CharSequence): Expect<T>
fun <T : Path> Expect<T>.notToStartWith(expected: Path): Expect<T>
fun <R, T : () -> R> Expect<T>.notToThrow(): Expect<R>
fun <R, T : () -> R> Expect<T>.notToThrow(assertionCreator: Expect<R>.() -> Unit): Expect<R>
val <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderSearchBehaviour>.only: IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>
val <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderSearchBehaviour>.only: IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>
val <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.only: MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>
val <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InOrderSearchBehaviour>.only: MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>
val <T : Path> Expect<T>.parent: Expect<Path>
fun <T : Path> Expect<T>.parent(assertionCreator: Expect<Path>.() -> Unit): Expect<T>
fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): Expect<T>
fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.regex(pattern: Regex, vararg otherPatterns: Regex): Expect<T>
@JvmName("regexIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): Expect<T>
fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): Expect<T>
fun <T : Path> Expect<T>.resolve(other: String): Expect<Path>
fun <T : Path> Expect<T>.resolve(other: String, assertionCreator: Expect<Path>.() -> Unit): Expect<T>
val <V, T : Pair<*, V>> Expect<T>.second: Expect<V>
fun <K, V, T : Pair<K, V>> Expect<T>.second(assertionCreator: Expect<V>.() -> Unit): Expect<T>
val <T : Collection<*>> Expect<T>.size: Expect<Int>
fun <E, T : Collection<E>> Expect<T>.size(assertionCreator: Expect<Int>.() -> Unit): Expect<T>
fun <T : CharSequence> Expect<T>.startsNotWith(expected: CharSequence): Expect<T>
fun <T : CharSequence> Expect<T>.startsNotWith(expected: Char): Expect<T>
fun <T : Path> Expect<T>.startsNotWith(expected: Path): Expect<T>
fun <T : CharSequence> Expect<T>.startsWith(expected: CharSequence): Expect<T>
fun <T : CharSequence> Expect<T>.startsWith(expected: Char): Expect<T>
fun <T : Path> Expect<T>.startsWith(expected: Path): Expect<T>
fun <T> Expect<T>.toBe(expected: T): Expect<T>
@JvmName("toBeNull") fun <T : BigDecimal> Expect<T?>.toBe(expected: Nothing?): Expect<T?>
fun <T : Path> Expect<T>.toBeAbsolute(): Expect<T>
fun <T : Path> Expect<T>.toBeADirectory(): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.toBeAfter(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.toBeAfter(expected: String): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeAfter(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeAfter(expected: ChronoZonedDateTime<*>): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.toBeAfterOrTheSamePointInTimeAs(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.toBeAfterOrTheSamePointInTimeAs(expected: String): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeAfterOrTheSamePointInTimeAs(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeAfterOrTheSamePointInTimeAs(expected: ChronoZonedDateTime<*>): Expect<T>
fun <T : Path> Expect<T>.toBeAnEmptyDirectory(): Expect<T>
inline fun <reified TSub : Any> Expect<*>.toBeAnInstanceOf(): Expect<TSub>
inline fun <reified TSub : Any> Expect<*>.toBeAnInstanceOf(noinline assertionCreator: Expect<TSub>.() -> Unit): Expect<TSub>
fun <T : Path> Expect<T>.toBeARegularFile(): Expect<T>
fun <T : Path> Expect<T>.toBeASymbolicLink(): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.toBeBefore(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.toBeBefore(expected: String): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeBefore(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeBefore(expected: ChronoZonedDateTime<*>): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.toBeBeforeOrTheSamePointInTimeAs(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.toBeBeforeOrTheSamePointInTimeAs(expected: String): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeBeforeOrTheSamePointInTimeAs(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeBeforeOrTheSamePointInTimeAs(expected: ChronoZonedDateTime<*>): Expect<T>
fun <T : CharSequence> Expect<T>.toBeEmpty(): Expect<T>
fun <T : Comparable<T>> Expect<T>.toBeEqualComparingTo(expected: T): Expect<T>
fun <T : Path> Expect<T>.toBeExecutable(): Expect<T>
fun <T : Comparable<T>> Expect<T>.toBeGreaterThan(expected: T): Expect<T>
fun <T : Comparable<T>> Expect<T>.toBeGreaterThanOrEqualTo(expected: T): Expect<T>
fun <T : Comparable<T>> Expect<T>.toBeLessThan(expected: T): Expect<T>
fun <T : Comparable<T>> Expect<T>.toBeLessThanOrEqualTo(expected: T): Expect<T>
fun <T : Any> Expect<T?>.toBeNullIfNullGivenElse(assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Expect<T?>
fun <E, T : Optional<E>> Expect<T>.toBePresent(): Expect<E>
fun <E, T : Optional<E>> Expect<T>.toBePresent(assertionCreator: Expect<E>.() -> Unit): Expect<T>
fun <T : Path> Expect<T>.toBeReadable(): Expect<T>
fun <T : Path> Expect<T>.toBeRelative(): Expect<T>
fun <T> Expect<T>.toBeTheInstance(expected: T): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.toBeTheSamePointInTimeAs(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.toBeTheSamePointInTimeAs(expected: String): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeTheSamePointInTimeAs(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeTheSamePointInTimeAs(expected: ChronoZonedDateTime<*>): Expect<T>
fun Expect<Float>.toBeWithErrorTolerance(expected: Float, tolerance: Float): Expect<Float>
fun Expect<Double>.toBeWithErrorTolerance(expected: Double, tolerance: Double): Expect<Double>
fun <T : BigDecimal> Expect<T>.toBeWithErrorTolerance(expected: BigDecimal, tolerance: BigDecimal): Expect<T>
fun <T : Path> Expect<T>.toBeWritable(): Expect<T>
val <T : CharSequence> Expect<T>.toContain: CharSequenceContains.EntryPointStep<T, NoOpSearchBehaviour>
fun <T : CharSequence> Expect<T>.toContain(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>
fun <E, T : Iterable<E>> Expect<T>.toContain(expected: E, vararg otherExpected: E): Expect<T>
fun <E : Any, T : Iterable<E?>> Expect<T>.toContain(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T : Iterable<E?>> Expect<T>.toContain(assertionCreatorOrNull: (Expect<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<E>.() -> Unit)?): Expect<T>
fun <K, V, T : Map<out K, V>> Expect<T>.toContain(keyValuePair: Pair<K, V>, vararg otherPairs: Pair<K, V>): Expect<T>
inline fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.toContain(keyValue: KeyValue<K, V>, vararg otherKeyValues: KeyValue<K, V>): Expect<T>
inline fun <reified E, T : Iterable<E>> Expect<T>.toContainElementsOf(expectedIterableLike: IterableLike): Expect<T>
fun <K, V : Any, T : Map<out K, V?>> Expect<T>.toContainEntriesOf(mapLike: MapLike): Expect<T>
fun <E, T : Iterable<E>> Expect<T>.toContainExactly(expected: E, vararg otherExpected: E, report: InOrderOnlyReportingOptions.() -> Unit = {}): Expect<T>
fun <E : Any, T : Iterable<E?>> Expect<T>.toContainExactly(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T : Iterable<E?>> Expect<T>.toContainExactly(assertionCreatorOrNull: (Expect<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<E>.() -> Unit)?, report: InOrderOnlyReportingOptions.() -> Unit = {}): Expect<T>
inline fun <reified E, T : Iterable<E>> Expect<T>.toContainExactlyElementsOf(expectedIterableLike: IterableLike, noinline report: InOrderOnlyReportingOptions.() -> Unit = {}): Expect<T>
fun <K, T : Map<out K, *>> Expect<T>.toContainKey(key: K): Expect<T>
fun <K, V, T : Map<out K, V>> Expect<T>.toContainOnly(keyValuePair: Pair<K, V>, vararg otherPairs: Pair<K, V>): Expect<T>
inline fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.toContainOnly(keyValue: KeyValue<K, V>, vararg otherKeyValues: KeyValue<K, V>): Expect<T>
fun <K, V : Any, T : Map<out K, V?>> Expect<T>.toContainOnlyEntriesOf(mapLike: MapLike): Expect<T>
fun <T : CharSequence> Expect<T>.toContainRegex(pattern: String, vararg otherPatterns: String): Expect<T>
fun <T : CharSequence> Expect<T>.toContainRegex(pattern: Regex, vararg otherPatterns: Regex): Expect<T>
fun <T : CharSequence> Expect<T>.toEndWith(expected: CharSequence): Expect<T>
fun <T : Path> Expect<T>.toEndWith(expected: Path): Expect<T>
fun <T> Expect<T>.toEqual(expected: T): Expect<T>
@JvmName("toBeNull") fun <T : BigDecimal> Expect<T?>.toEqual(expected: Nothing?): Expect<T?>
fun <T : BigDecimal> Expect<T>.toEqualIncludingScale(expected: T): Expect<T>
fun <K, V, T : Entry<K, V>> Expect<T>.toEqualKeyValue(key: K, value: V): Expect<T>
fun <T : Any> Expect<T?>.toEqualNullIfNullGivenElse(assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Expect<T?>
fun <T : BigDecimal> Expect<T>.toEqualNumerically(expected: T): Expect<T>
fun Expect<Float>.toEqualWithErrorTolerance(expected: Float, tolerance: Float): Expect<Float>
fun Expect<Double>.toEqualWithErrorTolerance(expected: Double, tolerance: Double): Expect<Double>
fun <T : Path> Expect<T>.toExist(): Expect<T>
fun <E, T : Iterable<E>> Expect<T>.toHaveElements(): Expect<T>
fun <E : Any, T : Iterable<E?>> Expect<T>.toHaveElementsAndAll(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T : Iterable<E?>> Expect<T>.toHaveElementsAndAny(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <E, T : Iterable<E>> Expect<T>.toHaveElementsAndNoDuplicates(): Expect<T>
fun <E : Any, T : Iterable<E?>> Expect<T>.toHaveElementsAndNone(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <T : Iterator<*>> Expect<T>.toHaveNext(): Expect<T>
fun <T : Collection<*>> Expect<T>.toHaveSize(expected: Int): Expect<T>
fun <T : Path> Expect<T>.toHaveTheDirectoryEntries(entry: String, vararg otherEntries: String): Expect<T>
fun <T : Path> Expect<T>.toHaveTheSameBinaryContentAs(targetPath: Path): Expect<T>
fun <T : Path> Expect<T>.toHaveTheSameTextualContentAs(targetPath: Path, sourceCharset: Charset = Charsets.UTF_8, targetCharset: Charset = Charsets.UTF_8): Expect<T>
fun <T : CharSequence> Expect<T>.toMatch(pattern: Regex): Expect<T>
fun <T : CharSequence> Expect<T>.toStartWith(expected: CharSequence): Expect<T>
fun <T : Path> Expect<T>.toStartWith(expected: Path): Expect<T>
inline fun <reified TExpected : Throwable> Expect<() -> Any?>.toThrow(): Expect<TExpected>
inline fun <reified TExpected : Throwable> Expect<() -> Any?>.toThrow(noinline assertionCreator: Expect<TExpected>.() -> Unit): Expect<TExpected>
fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>
@JvmName("valueIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>
fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>
fun <E, T> IterableLikeContains.CheckerStep<E, T, InAnyOrderSearchBehaviour>.value(expected: E): Expect<T>
fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): Expect<T>
fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.value(expected: E): Expect<T>
fun <K, V, T : Entry<K, V>> Expect<T>.value(assertionCreator: Expect<V>.() -> Unit): Expect<T>
val <V, T : Entry<*, V>> Expect<T>.value: Expect<V>
data class Value<out T> : Group<T>
fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.values(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>
@JvmName("valuesIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.values(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>
fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.values(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>
fun <E, T> IterableLikeContains.CheckerStep<E, T, InAnyOrderSearchBehaviour>.values(expected: E, vararg otherExpected: E): Expect<T>
fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): Expect<T>
fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): Expect<T>
fun <K, V, T : Map<out K, V>> Expect<T>.values(assertionCreator: Expect<Collection<V>>.() -> Unit): Expect<T>
val <V, T : Map<*, V>> Expect<T>.values: Expect<Collection<V>>
class Values<out T> : Group<T>, VarArgHelper<T>
val <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedSearchBehaviour>.within: IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedWithinSearchBehaviour>
fun <T> RootExpect<T>.withOptions(configuration: RootExpectBuilder.OptionsChooser<T>.() -> Unit): Expect<T>
fun <T> RootExpect<T>.withOptions(options: RootExpectOptions<T>): Expect<T>
fun <T, R> FeatureExpect<T, R>.withOptions(configuration: FeatureExpectOptionsChooser<R>.() -> Unit): Expect<R>
fun <T, R> FeatureExpect<T, R>.withOptions(options: FeatureExpectOptions<R>): Expect<R>
fun <T> RootExpect<T>.withRepresentation(textRepresentation: String): Expect<T>
fun <T> RootExpect<T>.withRepresentation(representationProvider: (T) -> Any): Expect<T>
fun <T, R> FeatureExpect<T, R>.withRepresentation(textRepresentation: String): Expect<R>
fun <T, R> FeatureExpect<T, R>.withRepresentation(representationProvider: (R) -> Any): Expect<R>
val Expect<LocalDate>.year: Expect<Int>
val Expect<LocalDateTime>.year: Expect<Int>
val Expect<ZonedDateTime>.year: Expect<Int>
fun Expect<LocalDate>.year(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDate>
fun Expect<LocalDateTime>.year(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDateTime>
fun Expect<ZonedDateTime>.year(assertionCreator: Expect<Int>.() -> Unit): Expect<ZonedDateTime>
package ch.tutteli.atrium.api.fluent.en_GB.creating.feature
Module Contents
class MetaFeatureOption<T>
Module Contents
MetaFeatureOption(expect: Expect<T>)
fun <R> f(property: KProperty0<R>): MetaFeature<R>
fun <R> f(f: KFunction0<R>): MetaFeature<R>
fun <A1, R> f(f: KFunction1<A1, R>, a1: A1): MetaFeature<R>
fun <A1, A2, R> f(f: KFunction2<A1, A2, R>, a1: A1, a2: A2): MetaFeature<R>
fun <A1, A2, A3, R> f(f: KFunction3<A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): MetaFeature<R>
fun <A1, A2, A3, A4, R> f(f: KFunction4<A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): MetaFeature<R>
fun <A1, A2, A3, A4, A5, R> f(f: KFunction5<A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): MetaFeature<R>
fun <R> f0(f: KFunction0<R>): MetaFeature<R>
fun <A1, R> f1(f: KFunction1<A1, R>, a1: A1): MetaFeature<R>
fun <A1, A2, R> f2(f: KFunction2<A1, A2, R>, a1: A1, a2: A2): MetaFeature<R>
fun <A1, A2, A3, R> f3(f: KFunction3<A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): MetaFeature<R>
fun <A1, A2, A3, A4, R> f4(f: KFunction4<A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): MetaFeature<R>
fun <A1, A2, A3, A4, A5, R> f5(f: KFunction5<A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): MetaFeature<R>
fun <R> p(property: KProperty0<R>): MetaFeature<R>
package ch.tutteli.atrium.api.fluent.en_GB.kotlin_1_3
package ch.tutteli.atrium.api.infix.en_GB
Module Contents
object absolute : Keyword
object aDirectory : Keyword
fun <T> all(t: T, vararg ts: T): All<T>
infix fun <E : Any, T : Iterable<E?>> Expect<T>.all(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
inline infix fun <T> Expect<T>.and(o: o): Expect<T>
infix fun <T> Expect<T>.and(assertionCreator: Expect<T>.() -> Unit): Expect<T>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderSearchBehaviour>.and(only: only): IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InOrderSearchBehaviour>.and(only: only): MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>
object anEmptyDirectory : Keyword
infix fun <E : Any, T : Iterable<E?>> Expect<T>.any(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
object aRegularFile : Keyword
infix fun <K, V, T : Map<out K, V>> Expect<T>.asEntries(o: o): Expect<Set<Entry<K, V>>>
infix fun <K, V, T : Map<out K, V>> Expect<T>.asEntries(assertionCreator: Expect<Set<Entry<K, V>>>.() -> Unit): Expect<T>
infix fun <E, T : Sequence<E>> Expect<T>.asIterable(o: o): Expect<Iterable<E>>
infix fun <E, T : Sequence<E>> Expect<T>.asIterable(assertionCreator: Expect<Iterable<E>>.() -> Unit): Expect<T>
infix fun <E> Expect<out Array<out E>>.asList(o: o): Expect<List<E>>
infix fun <E> Expect<Array<E>>.asList(assertionCreator: Expect<List<E>>.() -> Unit): Expect<Array<E>>
@JvmName("byteArrAsList") infix fun Expect<ByteArray>.asList(o: o): Expect<List<Byte>>
@JvmName("byteArrAsList") infix fun Expect<ByteArray>.asList(assertionCreator: Expect<List<Byte>>.() -> Unit): Expect<ByteArray>
@JvmName("charArrAsList") infix fun Expect<CharArray>.asList(o: o): Expect<List<Char>>
@JvmName("charArrAsList") infix fun Expect<CharArray>.asList(assertionCreator: Expect<List<Char>>.() -> Unit): Expect<CharArray>
@JvmName("shortArrAsList") infix fun Expect<ShortArray>.asList(o: o): Expect<List<Short>>
@JvmName("shortArrAsList") infix fun Expect<ShortArray>.asList(assertionCreator: Expect<List<Short>>.() -> Unit): Expect<ShortArray>
@JvmName("intArrAsList") infix fun Expect<IntArray>.asList(o: o): Expect<List<Int>>
@JvmName("intArrAsList") infix fun Expect<IntArray>.asList(assertionCreator: Expect<List<Int>>.() -> Unit): Expect<IntArray>
@JvmName("longArrAsList") infix fun Expect<LongArray>.asList(o: o): Expect<List<Long>>
@JvmName("longArrAsList") infix fun Expect<LongArray>.asList(assertionCreator: Expect<List<Long>>.() -> Unit): Expect<LongArray>
@JvmName("floatArrAsList") infix fun Expect<FloatArray>.asList(o: o): Expect<List<Float>>
@JvmName("floatArrAsList") infix fun Expect<FloatArray>.asList(assertionCreator: Expect<List<Float>>.() -> Unit): Expect<FloatArray>
@JvmName("doubleArrAsList") infix fun Expect<DoubleArray>.asList(o: o): Expect<List<Double>>
@JvmName("doubleArrAsList") infix fun Expect<DoubleArray>.asList(assertionCreator: Expect<List<Double>>.() -> Unit): Expect<DoubleArray>
@JvmName("boolArrAsList") infix fun Expect<BooleanArray>.asList(o: o): Expect<List<Boolean>>
@JvmName("boolArrAsList") infix fun Expect<BooleanArray>.asList(assertionCreator: Expect<List<Boolean>>.() -> Unit): Expect<BooleanArray>
infix fun <E, T : Iterable<E>> Expect<T>.asList(o: o): Expect<List<E>>
infix fun <E, T : Iterable<E>> Expect<T>.asList(assertionCreator: Expect<List<E>>.() -> Unit): Expect<T>
infix fun <T : File> Expect<T>.asPath(o: o): Expect<Path>
infix fun <T : File> Expect<T>.asPath(assertionCreator: Expect<Path>.() -> Unit): Expect<T>
fun <E> aSuccess(assertionCreator: Expect<E>.() -> Unit): SuccessWithCreator<E>
object aSuccess : Keyword
object aSymbolicLink : Keyword
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.atLeast(times: Int): AtLeastCheckerStep<T, S>
infix fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.atLeast(times: Int): AtLeastCheckerStep<E, T, S>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.atMost(times: Int): AtMostCheckerStep<T, S>
infix fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.atMost(times: Int): AtMostCheckerStep<E, T, S>
infix fun <T> Expect<T>.because(keyWithCreator: KeyWithCreator<String, T>): Expect<T>
object blank : Keyword
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderSearchBehaviour>.but(only: only): IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.but(only: only): MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> AtLeastCheckerStep<T, S>.butAtMost(times: Int): ButAtMostCheckerStep<T, S>
infix fun <E, T, S : InAnyOrderSearchBehaviour> AtLeastCheckerStep<E, T, S>.butAtMost(times: Int): ButAtMostCheckerStep<E, T, S>
object case : Keyword
inline fun <reified TExpected : Throwable> Expect<out Throwable>.cause(): Expect<TExpected>
inline infix fun <reified TExpected : Throwable> Expect<out Throwable>.cause(noinline assertionCreator: Expect<TExpected>.() -> Unit): Expect<TExpected>
infix fun <T : CharSequence> Expect<T>.contains(o: o): CharSequenceContains.EntryPointStep<T, NoOpSearchBehaviour>
infix fun <T : CharSequence> Expect<T>.contains(expected: CharSequenceOrNumberOrChar): Expect<T>
infix fun <T : CharSequence> Expect<T>.contains(values: Values<CharSequenceOrNumberOrChar>): Expect<T>
infix fun <T : CharSequence> Expect<T>.contains(pattern: Regex): Expect<T>
infix fun <T : CharSequence> Expect<T>.contains(regexPatterns: RegexPatterns): Expect<T>
infix fun <T : CharSequence> Expect<T>.contains(patterns: All<Regex>): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.contains(expected: E): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.contains(values: Values<E>): Expect<T>
infix fun <E : Any, T : Iterable<E?>> Expect<T>.contains(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <E : Any, T : Iterable<E?>> Expect<T>.contains(entries: Entries<E>): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.contains(noDuplicates: noDuplicates): Expect<T>
infix fun <K, V, T : Map<out K, V>> Expect<T>.contains(keyValuePair: Pair<K, V>): Expect<T>
infix fun <K, V, T : Map<out K, V>> Expect<T>.contains(keyValuePairs: Pairs<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.contains(keyValue: KeyWithValueCreator<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.contains(allKeyValues: KeyValues<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.contains(all: All<KeyWithValueCreator<K, V>>): Expect<T>
inline infix fun <reified E, T : Iterable<E>> Expect<T>.containsElementsOf(expectedIterableLike: IterableLike): Expect<T>
infix fun <K, V : Any, T : Map<out K, V?>> Expect<T>.containsEntriesOf(mapLike: MapLike): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.containsExactly(expected: E): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.containsExactly(values: Values<E>): Expect<T>
infix fun <E : Any, T : Iterable<E?>> Expect<T>.containsExactly(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <E : Any, T : Iterable<E?>> Expect<T>.containsExactly(entries: Entries<E>): Expect<T>
inline infix fun <reified E, T : Iterable<E>> Expect<T>.containsExactlyElementsOf(expectedIterableLike: IterableLike): Expect<T>
infix fun <K, T : Map<out K, *>> Expect<T>.containsKey(key: K): Expect<T>
infix fun <T : CharSequence> Expect<T>.containsNot(o: o): NotCheckerStep<T, NotSearchBehaviour>
infix fun <T : CharSequence> Expect<T>.containsNot(expected: CharSequenceOrNumberOrChar): Expect<T>
infix fun <T : CharSequence> Expect<T>.containsNot(values: Values<CharSequenceOrNumberOrChar>): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.containsNot(expected: E): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.containsNot(values: Values<E>): Expect<T>
infix fun <K, T : Map<out K, *>> Expect<T>.containsNotKey(key: K): Expect<T>
infix fun <K, V, T : Map<out K, V>> Expect<T>.containsOnly(keyValuePair: Pair<K, V>): Expect<T>
infix fun <K, V, T : Map<out K, V>> Expect<T>.containsOnly(keyValuePairs: Pairs<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.containsOnly(keyValue: KeyWithValueCreator<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.containsOnly(allKeyValues: KeyValues<K, V>): Expect<T>
infix fun <K, V : Any, T : Map<out K, V?>> Expect<T>.containsOnlyEntriesOf(mapLike: MapLike): Expect<T>
infix fun <T : CharSequence> Expect<T>.containsRegex(pattern: String): Expect<T>
val Expect<LocalDate>.day: Expect<Int>
val Expect<LocalDateTime>.day: Expect<Int>
val Expect<ZonedDateTime>.day: Expect<Int>
infix fun Expect<LocalDate>.day(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDate>
infix fun Expect<LocalDateTime>.day(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDateTime>
infix fun Expect<ZonedDateTime>.day(assertionCreator: Expect<Int>.() -> Unit): Expect<ZonedDateTime>
val Expect<LocalDate>.dayOfWeek: Expect<DayOfWeek>
val Expect<LocalDateTime>.dayOfWeek: Expect<DayOfWeek>
val Expect<ZonedDateTime>.dayOfWeek: Expect<DayOfWeek>
infix fun Expect<LocalDate>.dayOfWeek(assertionCreator: Expect<DayOfWeek>.() -> Unit): Expect<LocalDate>
infix fun Expect<LocalDateTime>.dayOfWeek(assertionCreator: Expect<DayOfWeek>.() -> Unit): Expect<LocalDateTime>
infix fun Expect<ZonedDateTime>.dayOfWeek(assertionCreator: Expect<DayOfWeek>.() -> Unit): Expect<ZonedDateTime>
fun directoryEntries(entry: String, vararg otherEntries: String): DirectoryEntries
object elements : Keyword
infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
@JvmName("elementsOfIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
@JvmName("elementsOfIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
inline infix fun <reified E, T> IterableLikeContains.CheckerStep<E, T, InAnyOrderSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
inline infix fun <reified E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
inline infix fun <reified E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
object empty : Keyword
infix fun <T : CharSequence> Expect<T>.endsNotWith(expected: CharSequence): Expect<T>
infix fun <T : CharSequence> Expect<T>.endsNotWith(expected: Char): Expect<T>
infix fun <T : Path> Expect<T>.endsNotWith(expected: Path): Expect<T>
infix fun <T : CharSequence> Expect<T>.endsWith(expected: CharSequence): Expect<T>
infix fun <T : CharSequence> Expect<T>.endsWith(expected: Char): Expect<T>
infix fun <T : Path> Expect<T>.endsWith(expected: Path): Expect<T>
fun <T : Any> entries(assertionCreatorOrNull: (Expect<T>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<T>.() -> Unit)?): Entries<T>
object entries : Keyword
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.entriesOf(expectedMapLike: MapLike): Expect<T>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>.entriesOf(expectedMapLike: MapLike): Expect<T>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>.entriesOf(expectedMapLike: MapLike): Expect<T>
fun <T : Any> entry(assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Entry<T>
infix fun <E : Any, T> IterableLikeContains.CheckerStep<out E?, T, InAnyOrderSearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.entry(keyValuePair: Pair<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderSearchBehaviour>.entry(keyValue: KeyWithValueCreator<K, V>): Expect<T>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>.entry(keyValuePair: Pair<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderOnlySearchBehaviour>.entry(keyValue: KeyWithValueCreator<K, V>): Expect<T>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>.entry(keyValuePair: Pair<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InOrderOnlySearchBehaviour>.entry(keyValue: KeyWithValueCreator<K, V>): Expect<T>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.exactly(times: Int): ExactlyCheckerStep<T, S>
infix fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.exactly(times: Int): ExactlyCheckerStep<E, T, S>
object executable : Keyword
object existing : Keyword
@Target([AnnotationTarget.FUNCTION]) annotation class ExperimentalWithOptions
val <T : Path> Expect<T>.extension: Expect<String>
infix fun <T : Path> Expect<T>.extension(assertionCreator: Expect<String>.() -> Unit): Expect<T>
fun <T, R> MetaFeatureOption<T>.f(description: String, provider: R): MetaFeature<R>
fun <T, R> feature(: T.() -> R, assertionCreator: Expect<R>.() -> Unit): ExtractorWithCreator<T, R>
infix fun <T, R> Expect<T>.feature(property: KProperty1<in T, R>): FeatureExpect<T, R>
infix fun <T, R> Expect<T>.feature(f: KFunction1<T, R>): FeatureExpect<T, R>
infix fun <T, R> Expect<T>.feature(of: Feature<in T, R>): FeatureExpect<T, R>
infix fun <T, R> Expect<T>.feature(of: FeatureWithCreator<in T, R>): Expect<T>
infix fun <T, R> Expect<T>.feature(provider: MetaFeatureOption<T>.(T) -> MetaFeature<R>): FeatureExpect<T, R>
infix fun <T, R> Expect<T>.feature(of: MetaFeatureOptionWithCreator<T, R>): Expect<T>
val <T : Path> Expect<T>.fileName: Expect<String>
infix fun <T : Path> Expect<T>.fileName(assertionCreator: Expect<String>.() -> Unit): Expect<T>
val <T : Path> Expect<T>.fileNameWithoutExtension: Expect<String>
infix fun <T : Path> Expect<T>.fileNameWithoutExtension(assertionCreator: Expect<String>.() -> Unit): Expect<T>
val <K, T : Pair<K, *>> Expect<T>.first: Expect<K>
infix fun <K, V, T : Pair<K, V>> Expect<T>.first(assertionCreator: Expect<K>.() -> Unit): Expect<T>
infix fun <E, T : List<E>> Expect<T>.get(index: Int): Expect<E>
infix fun <E, T : List<E>> Expect<T>.get(index: IndexWithCreator<E>): Expect<T>
infix fun <K, V, T : Map<out K, V>> Expect<T>.getExisting(key: K): Expect<V>
infix fun <K, V, T : Map<out K, V>> Expect<T>.getExisting(key: KeyWithCreator<K, V>): Expect<T>
object group : Keyword
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.grouped(entries: entries): IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedSearchBehaviour>
infix fun <E, T : Iterable<E>> Expect<T>.has(next: next): Expect<T>
infix fun <T : Path> Expect<T>.has(directoryEntries: DirectoryEntries): Expect<T>
infix fun <T : Path> Expect<T>.hasDirectoryEntry(entry: String): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.hasNot(next: next): Expect<T>
infix fun <T : Path> Expect<T>.hasSameBinaryContentAs(targetPath: Path): Expect<T>
infix fun <T : Path> Expect<T>.hasSameTextualContentAs(targetPath: Path): Expect<T>
infix fun <T : Path> Expect<T>.hasSameTextualContentAs(pathWithEncoding: PathWithEncoding): Expect<T>
infix fun <T : Collection<*>> Expect<T>.hasSize(expected: Int): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, NoOpSearchBehaviour>.ignoring(case: case): CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>
infix fun <T : CharSequence> NotCheckerStep<T, NotSearchBehaviour>.ignoring(case: case): NotCheckerStep<T, IgnoringCaseSearchBehaviour>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<E, Group<E>>): Expect<T>
@JvmName("inAnyOrderEntries") infix fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<(Expect<E>.() -> Unit)?, Group<(Expect<E>.() -> Unit)?>>): Expect<T>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>.inAny(order: order): IterableLikeContains.EntryPointStep<E, T, InAnyOrderSearchBehaviour>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>.inAny(order: order): MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>
fun <E> index(index: Int, assertionCreator: Expect<E>.() -> Unit): IndexWithCreator<E>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>.inGiven(order: order): IterableLikeContains.EntryPointStep<E, T, InOrderSearchBehaviour>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>.inGiven(order: order): MapLikeContains.EntryPointStep<K, V, T, InOrderSearchBehaviour>
inline fun <reified TSub : Any> Expect<*>.isA(): Expect<TSub>
inline infix fun <reified TSub : Any> Expect<*>.isA(noinline assertionCreator: Expect<TSub>.() -> Unit): Expect<TSub>
infix fun <T : ChronoLocalDate> Expect<T>.isAfter(expected: ChronoLocalDate): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.isAfter(expected: String): Expect<T>
infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isAfter(expected: ChronoLocalDateTime<*>): Expect<T>
infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isAfter(expected: ChronoZonedDateTime<*>): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.isAfterOrEqual(expected: ChronoLocalDate): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.isAfterOrEqual(expected: String): Expect<T>
infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isAfterOrEqual(expected: ChronoLocalDateTime<*>): Expect<T>
infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isAfterOrEqual(expected: ChronoZonedDateTime<*>): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.isBefore(expected: ChronoLocalDate): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.isBefore(expected: String): Expect<T>
infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isBefore(expected: ChronoLocalDateTime<*>): Expect<T>
infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isBefore(expected: ChronoZonedDateTime<*>): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.isBeforeOrEqual(expected: ChronoLocalDate): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.isBeforeOrEqual(expected: String): Expect<T>
infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isBeforeOrEqual(expected: ChronoLocalDateTime<*>): Expect<T>
infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isBeforeOrEqual(expected: ChronoZonedDateTime<*>): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.isEqual(expected: ChronoLocalDate): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.isEqual(expected: String): Expect<T>
infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isEqual(expected: ChronoLocalDateTime<*>): Expect<T>
infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isEqual(expected: ChronoZonedDateTime<*>): Expect<T>
infix fun <T : Comparable<T>> Expect<T>.isEqualComparingTo(expected: T): Expect<T>
infix fun <T : BigDecimal> Expect<T>.isEqualIncludingScale(expected: T): Expect<T>
infix fun <T : Comparable<T>> Expect<T>.isGreaterThan(expected: T): Expect<T>
infix fun <T : Comparable<T>> Expect<T>.isGreaterThanOrEqual(expected: T): Expect<T>
infix fun <K, V, T : Entry<K, V>> Expect<T>.isKeyValue(keyValuePair: Pair<K, V>): Expect<T>
infix fun <T : Comparable<T>> Expect<T>.isLessThan(expected: T): Expect<T>
infix fun <T : Comparable<T>> Expect<T>.isLessThanOrEqual(expected: T): Expect<T>
infix fun <T> Expect<T>.isNoneOf(values: Values<T>): Expect<T>
infix fun <T : BigDecimal> Expect<T>.isNotEqualIncludingScale(expected: T): Expect<T>
infix fun <T> Expect<T>.isNotIn(expected: IterableLike): Expect<T>
infix fun <T : BigDecimal> Expect<T>.isNotNumericallyEqualTo(expected: T): Expect<T>
infix fun <T> Expect<T>.isNotSameAs(expected: T): Expect<T>
infix fun <T : BigDecimal> Expect<T>.isNumericallyEqualTo(expected: T): Expect<T>
infix fun <T> Expect<T>.isSameAs(expected: T): Expect<T>
inline val <T> Expect<T>.it: Expect<T>
inline val <T> Expect<T>.its: Expect<T>
infix fun <T, R> Expect<T>.its(: T.() -> R): FeatureExpect<T, R>
infix fun <T, R> Expect<T>.its(: ExtractorWithCreator<T, R>): Expect<T>
fun <K, V> key(key: K, assertionCreator: Expect<V>.() -> Unit): KeyWithCreator<K, V>
infix fun <K, V, T : Entry<K, V>> Expect<T>.key(assertionCreator: Expect<K>.() -> Unit): Expect<T>
val <K, T : Entry<K, *>> Expect<T>.key: Expect<K>
val <K, T : Map<out K, *>> Expect<T>.keys: Expect<Set<K>>
infix fun <K, V, T : Map<out K, V>> Expect<T>.keys(assertionCreator: Expect<Set<K>>.() -> Unit): Expect<T>
fun <K, V : Any> keyValue(key: K, valueAssertionCreatorOrNull: (Expect<V>.() -> Unit)?): KeyWithValueCreator<K, V>
fun <K, V : Any> keyValues(keyValue: KeyWithValueCreator<K, V>, vararg otherKeyValues: KeyWithValueCreator<K, V>): KeyValues<K, V>
interface Keyword
infix fun <T : CharSequence> Expect<T>.matches(expected: Regex): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.matchFor(pattern: Regex): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.matchFor(patterns: All<Regex>): Expect<T>
infix fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.max(o: o): Expect<E>
infix fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.max(assertionCreator: Expect<E>.() -> Unit): Expect<T>
val <T : Throwable> Expect<T>.message: Expect<String>
infix fun <T : Throwable> Expect<T>.message(assertionCreator: Expect<String>.() -> Unit): Expect<T>
infix fun <T : Throwable> Expect<T>.messageContains(expected: CharSequenceOrNumberOrChar): Expect<T>
infix fun <T : Throwable> Expect<T>.messageContains(values: Values<Any>): Expect<T>
infix fun <T : Throwable> Expect<T>.messageToContain(expected: CharSequenceOrNumberOrChar): Expect<T>
infix fun <T : Throwable> Expect<T>.messageToContain(values: Values<Any>): Expect<T>
infix fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.min(o: o): Expect<E>
infix fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.min(assertionCreator: Expect<E>.() -> Unit): Expect<T>
infix fun <T : CharSequence> Expect<T>.mismatches(expected: Regex): Expect<T>
val Expect<LocalDate>.month: Expect<Int>
val Expect<LocalDateTime>.month: Expect<Int>
val Expect<ZonedDateTime>.month: Expect<Int>
infix fun Expect<LocalDate>.month(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDate>
infix fun Expect<LocalDateTime>.month(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDateTime>
infix fun Expect<ZonedDateTime>.month(assertionCreator: Expect<Int>.() -> Unit): Expect<ZonedDateTime>
object next : Keyword
object noDuplicates : Keyword
infix fun <E : Any, T : Iterable<E?>> Expect<T>.none(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerStep<T, S>
infix fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerStep<E, T, S>
infix fun <T> Expect<T>.notToBe(expected: T): Expect<T>
infix fun <T : CharSequence> Expect<T>.notToBe(empty: empty): Expect<T>
infix fun <T : CharSequence> Expect<T>.notToBe(blank: blank): Expect<T>
infix fun <T : Path> Expect<T>.notToBe(existing: existing): Expect<T>
infix fun <T : Path> Expect<T>.notToBe(readable: readable): Expect<T>
infix fun <T : Path> Expect<T>.notToBe(writable: writable): Expect<T>
infix fun <T : Path> Expect<T>.notToBe(executable: executable): Expect<T>
infix fun <T : Comparable<T>> Expect<T>.notToBeGreaterThan(expected: T): Expect<T>
infix fun <T : Comparable<T>> Expect<T>.notToBeLessThan(expected: T): Expect<T>
inline infix fun <reified T : Any> Expect<T?>.notToBeNull(o: o): Expect<T>
inline infix fun <reified T : Any> Expect<T?>.notToBeNull(noinline assertionCreator: Expect<T>.() -> Unit): Expect<T>
infix fun <T> Expect<T>.notToBeTheInstance(expected: T): Expect<T>
infix fun <T : CharSequence> Expect<T>.notToContain(o: o): NotCheckerStep<T, NotSearchBehaviour>
infix fun <T : CharSequence> Expect<T>.notToContain(expected: CharSequenceOrNumberOrChar): Expect<T>
infix fun <T : CharSequence> Expect<T>.notToContain(values: Values<CharSequenceOrNumberOrChar>): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.notToContain(expected: E): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.notToContain(values: Values<E>): Expect<T>
infix fun <K, T : Map<out K, *>> Expect<T>.notToContainKey(key: K): Expect<T>
infix fun <T : CharSequence> Expect<T>.notToEndWith(expected: CharSequence): Expect<T>
infix fun <T : Path> Expect<T>.notToEndWith(expected: Path): Expect<T>
infix fun <T> Expect<T>.notToEqual(expected: T): Expect<T>
infix fun <T : BigDecimal> Expect<T>.notToEqualIncludingScale(expected: T): Expect<T>
inline infix fun <reified T : Any> Expect<T?>.notToEqualNull(o: o): Expect<T>
inline infix fun <reified T : Any> Expect<T?>.notToEqualNull(noinline assertionCreator: Expect<T>.() -> Unit): Expect<T>
infix fun <T : BigDecimal> Expect<T>.notToEqualNumerically(expected: T): Expect<T>
infix fun <T> Expect<T>.notToEqualOneIn(expected: IterableLike): Expect<T>
infix fun <T> Expect<T>.notToEqualOneOf(values: Values<T>): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.notToHave(elements: elements): Expect<T>
infix fun <T : Iterator<*>> Expect<T>.notToHave(next: next): Expect<T>
infix fun <T : CharSequence> Expect<T>.notToMatch(pattern: Regex): Expect<T>
infix fun <T : CharSequence> Expect<T>.notToStartWith(expected: CharSequence): Expect<T>
infix fun <T : Path> Expect<T>.notToStartWith(expected: Path): Expect<T>
fun <R, T : () -> R> Expect<T>.notToThrow(): Expect<R>
infix fun <R, T : () -> R> Expect<T>.notToThrow(assertionCreator: Expect<R>.() -> Unit): Expect<R>
object o : Keyword
fun <T> of(reason: String, assertionCreator: Expect<T>.() -> Unit): KeyWithCreator<String, T>
fun <T, A1, R> of(f: KFunction2<T, A1, R>, a1: A1): Feature<T, R>
fun <T, A1, A2, R> of(f: KFunction3<T, A1, A2, R>, a1: A1, a2: A2): Feature<T, R>
fun <T, A1, A2, A3, R> of(f: KFunction4<T, A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): Feature<T, R>
fun <T, A1, A2, A3, A4, R> of(f: KFunction5<T, A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): Feature<T, R>
fun <T, A1, A2, A3, A4, A5, R> of(f: KFunction6<T, A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): Feature<T, R>
fun <T, R> of(property: KProperty1<in T, R>, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>
fun <T, R> of(f: KFunction1<T, R>, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>
fun <T, A1, R> of(f: KFunction2<T, A1, R>, a1: A1, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>
fun <T, A1, A2, R> of(f: KFunction3<T, A1, A2, R>, a1: A1, a2: A2, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>
fun <T, A1, A2, A3, R> of(f: KFunction4<T, A1, A2, A3, R>, a1: A1, a2: A2, a3: A3, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>
fun <T, A1, A2, A3, A4, R> of(f: KFunction5<T, A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>
fun <T, A1, A2, A3, A4, A5, R> of(f: KFunction6<T, A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>
fun <T, R> of(provider: MetaFeatureOption<T>.(T) -> MetaFeature<R>, assertionCreator: Expect<R>.() -> Unit): MetaFeatureOptionWithCreator<T, R>
fun <T, R> of(description: String, : T.() -> R): Feature<T, R>
fun <T, R> of(description: String, : T.() -> R, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>
object only : Keyword
fun <E> order(firstGroup: Group<E>, secondGroup: Group<E>, vararg otherExpectedGroups: Group<E>): Order<E, Group<E>>
object order : Keyword
fun <K, V> pairs(pair: Pair<K, V>, vararg otherPairs: Pair<K, V>): Pairs<K, V>
val <T : Path> Expect<T>.parent: Expect<Path>
infix fun <T : Path> Expect<T>.parent(assertionCreator: Expect<Path>.() -> Unit): Expect<T>
fun <E> path(path: String, assertionCreator: Expect<E>.() -> Unit): PathWithCreator<E>
fun <E> present(assertionCreator: Expect<E>.() -> Unit): PresentWithCreator<E>
object present : Keyword
object readable : Keyword
infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.regex(pattern: String): Expect<T>
@JvmName("regexIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.regex(pattern: String): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.regex(pattern: String): Expect<T>
fun regexPatterns(pattern: String, vararg otherPatterns: String): RegexPatterns
object relative : Keyword
infix fun <T : Path> Expect<T>.resolve(other: String): Expect<Path>
infix fun <T : Path> Expect<T>.resolve(path: PathWithCreator<Path>): Expect<T>
val <V, T : Pair<*, V>> Expect<T>.second: Expect<V>
infix fun <K, V, T : Pair<K, V>> Expect<T>.second(assertionCreator: Expect<V>.() -> Unit): Expect<T>
val <T : Collection<*>> Expect<T>.size: Expect<Int>
infix fun <E, T : Collection<E>> Expect<T>.size(assertionCreator: Expect<Int>.() -> Unit): Expect<T>
infix fun <T : CharSequence> Expect<T>.startsNotWith(expected: CharSequence): Expect<T>
infix fun <T : CharSequence> Expect<T>.startsNotWith(expected: Char): Expect<T>
infix fun <T : Path> Expect<T>.startsNotWith(expected: Path): Expect<T>
infix fun <T : CharSequence> Expect<T>.startsWith(expected: CharSequence): Expect<T>
infix fun <T : CharSequence> Expect<T>.startsWith(expected: Char): Expect<T>
infix fun <T : Path> Expect<T>.startsWith(expected: Path): Expect<T>
fun <E> success(assertionCreator: Expect<E>.() -> Unit): SuccessWithCreator<E>
object success : Keyword
infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.the(values: Values<CharSequenceOrNumberOrChar>): Expect<T>
@JvmName("valuesIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.the(values: Values<CharSequenceOrNumberOrChar>): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.the(values: Values<CharSequenceOrNumberOrChar>): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.the(patterns: RegexPatterns): Expect<T>
@JvmName("regexIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.the(patterns: RegexPatterns): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.the(patterns: RegexPatterns): Expect<T>
infix fun <E, T> IterableLikeContains.CheckerStep<E, T, InAnyOrderSearchBehaviour>.the(values: Values<E>): Expect<T>
infix fun <E : Any, T> IterableLikeContains.CheckerStep<out E?, T, InAnyOrderSearchBehaviour>.the(entries: Entries<E>): Expect<T>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.the(values: Values<E>): Expect<T>
infix fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InAnyOrderOnlySearchBehaviour>.the(entries: Entries<E>): Expect<T>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.the(values: Values<E>): Expect<T>
infix fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlySearchBehaviour>.the(entries: Entries<E>): Expect<T>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.the(pairs: Pairs<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderSearchBehaviour>.the(keyValues: KeyValues<K, V>): Expect<T>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>.the(keyValuePairs: Pairs<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderOnlySearchBehaviour>.the(keyValues: KeyValues<K, V>): Expect<T>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>.the(keyValuePairs: Pairs<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InOrderOnlySearchBehaviour>.the(keyValues: KeyValues<K, V>): Expect<T>
infix fun <T> Expect<T>.toBe(expected: T): Expect<T>
infix fun <T : CharSequence> Expect<T>.toBe(empty: empty): Expect<T>
@JvmName("toBeNull") infix fun <T : BigDecimal> Expect<T?>.toBe(expected: Nothing?): Expect<T?>
infix fun <E, T : Optional<E>> Expect<T>.toBe(present: present): FeatureExpect<T, E>
infix fun <E, T : Optional<E>> Expect<T>.toBe(present: PresentWithCreator<E>): Expect<T>
infix fun <T : Path> Expect<T>.toBe(existing: existing): Expect<T>
infix fun <T : Path> Expect<T>.toBe(readable: readable): Expect<T>
infix fun <T : Path> Expect<T>.toBe(writable: writable): Expect<T>
infix fun <T : Path> Expect<T>.toBe(executable: executable): Expect<T>
infix fun <T : Path> Expect<T>.toBe(aRegularFile: aRegularFile): Expect<T>
infix fun <T : Path> Expect<T>.toBe(aDirectory: aDirectory): Expect<T>
infix fun <T : Path> Expect<T>.toBe(aSymbolicLink: aSymbolicLink): Expect<T>
infix fun <T : Path> Expect<T>.toBe(absolute: absolute): Expect<T>
infix fun <T : Path> Expect<T>.toBe(relative: relative): Expect<T>
infix fun <T : Path> Expect<T>.toBe(anEmptyDirectory: anEmptyDirectory): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.toBeAfter(expected: ChronoLocalDate): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.toBeAfter(expected: String): Expect<T>
infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeAfter(expected: ChronoLocalDateTime<*>): Expect<T>
infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeAfter(expected: ChronoZonedDateTime<*>): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.toBeAfterOrTheSamePointInTimeAs(expected: ChronoLocalDate): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.toBeAfterOrTheSamePointInTimeAs(expected: String): Expect<T>
infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeAfterOrTheSamePointInTimeAs(expected: ChronoLocalDateTime<*>): Expect<T>
infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeAfterOrTheSamePointInTimeAs(expected: ChronoZonedDateTime<*>): Expect<T>
inline fun <reified TSub : Any> Expect<*>.toBeAnInstanceOf(): Expect<TSub>
inline infix fun <reified TSub : Any> Expect<*>.toBeAnInstanceOf(noinline assertionCreator: Expect<TSub>.() -> Unit): Expect<TSub>
infix fun <T : ChronoLocalDate> Expect<T>.toBeBefore(expected: ChronoLocalDate): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.toBeBefore(expected: String): Expect<T>
infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeBefore(expected: ChronoLocalDateTime<*>): Expect<T>
infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeBefore(expected: ChronoZonedDateTime<*>): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.toBeBeforeOrTheSamePointInTimeAs(expected: ChronoLocalDate): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.toBeBeforeOrTheSamePointInTimeAs(expected: String): Expect<T>
infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeBeforeOrTheSamePointInTimeAs(expected: ChronoLocalDateTime<*>): Expect<T>
infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeBeforeOrTheSamePointInTimeAs(expected: ChronoZonedDateTime<*>): Expect<T>
infix fun <T : Comparable<T>> Expect<T>.toBeEqualComparingTo(expected: T): Expect<T>
infix fun <T : Comparable<T>> Expect<T>.toBeGreaterThan(expected: T): Expect<T>
infix fun <T : Comparable<T>> Expect<T>.toBeGreaterThanOrEqualTo(expected: T): Expect<T>
infix fun <T : Comparable<T>> Expect<T>.toBeLessThan(expected: T): Expect<T>
infix fun <T : Comparable<T>> Expect<T>.toBeLessThanOrEqualTo(expected: T): Expect<T>
infix fun <T : Any> Expect<T?>.toBeNullIfNullGivenElse(assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Expect<T?>
infix fun <T> Expect<T>.toBeTheInstance(expected: T): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.toBeTheSamePointInTimeAs(expected: ChronoLocalDate): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.toBeTheSamePointInTimeAs(expected: String): Expect<T>
infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeTheSamePointInTimeAs(expected: ChronoLocalDateTime<*>): Expect<T>
infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeTheSamePointInTimeAs(expected: ChronoZonedDateTime<*>): Expect<T>
infix fun <T : CharSequence> Expect<T>.toContain(o: o): CharSequenceContains.EntryPointStep<T, NoOpSearchBehaviour>
infix fun <T : CharSequence> Expect<T>.toContain(expected: CharSequenceOrNumberOrChar): Expect<T>
infix fun <T : CharSequence> Expect<T>.toContain(values: Values<CharSequenceOrNumberOrChar>): Expect<T>
infix fun <T : CharSequence> Expect<T>.toContain(pattern: Regex): Expect<T>
infix fun <T : CharSequence> Expect<T>.toContain(regexPatterns: RegexPatterns): Expect<T>
infix fun <T : CharSequence> Expect<T>.toContain(patterns: All<Regex>): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.toContain(expected: E): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.toContain(values: Values<E>): Expect<T>
infix fun <E : Any, T : Iterable<E?>> Expect<T>.toContain(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <E : Any, T : Iterable<E?>> Expect<T>.toContain(entries: Entries<E>): Expect<T>
infix fun <K, V, T : Map<out K, V>> Expect<T>.toContain(keyValuePair: Pair<K, V>): Expect<T>
infix fun <K, V, T : Map<out K, V>> Expect<T>.toContain(keyValuePairs: Pairs<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.toContain(keyValue: KeyWithValueCreator<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.toContain(keyValues: KeyValues<K, V>): Expect<T>
inline infix fun <reified E, T : Iterable<E>> Expect<T>.toContainElementsOf(expectedIterableLike: IterableLike): Expect<T>
infix fun <K, V : Any, T : Map<out K, V?>> Expect<T>.toContainEntriesOf(mapLike: MapLike): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.toContainExactly(expected: E): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.toContainExactly(values: Values<E>): Expect<T>
infix fun <E : Any, T : Iterable<E?>> Expect<T>.toContainExactly(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <E : Any, T : Iterable<E?>> Expect<T>.toContainExactly(entries: Entries<E>): Expect<T>
inline infix fun <reified E, T : Iterable<E>> Expect<T>.toContainExactlyElementsOf(expectedIterableLike: IterableLike): Expect<T>
infix fun <K, T : Map<out K, *>> Expect<T>.toContainKey(key: K): Expect<T>
infix fun <K, V, T : Map<out K, V>> Expect<T>.toContainOnly(keyValuePair: Pair<K, V>): Expect<T>
infix fun <K, V, T : Map<out K, V>> Expect<T>.toContainOnly(keyValuePairs: Pairs<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.toContainOnly(keyValue: KeyWithValueCreator<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.toContainOnly(keyValues: KeyValues<K, V>): Expect<T>
infix fun <K, V : Any, T : Map<out K, V?>> Expect<T>.toContainOnlyEntriesOf(mapLike: MapLike): Expect<T>
infix fun <T : CharSequence> Expect<T>.toContainRegex(pattern: String): Expect<T>
infix fun <T : CharSequence> Expect<T>.toEndWith(expected: CharSequence): Expect<T>
infix fun <T : Path> Expect<T>.toEndWith(expected: Path): Expect<T>
infix fun <T> Expect<T>.toEqual(expected: T): Expect<T>
@JvmName("toBeNull") infix fun <T : BigDecimal> Expect<T?>.toEqual(expected: Nothing?): Expect<T?>
infix fun <T : BigDecimal> Expect<T>.toEqualIncludingScale(expected: T): Expect<T>
infix fun <K, V, T : Entry<K, V>> Expect<T>.toEqualKeyValue(keyValuePair: Pair<K, V>): Expect<T>
infix fun <T : Any> Expect<T?>.toEqualNullIfNullGivenElse(assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Expect<T?>
infix fun <T : BigDecimal> Expect<T>.toEqualNumerically(expected: T): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.toHave(elements: elements): Expect<T>
infix fun <T : Iterator<*>> Expect<T>.toHave(next: next): Expect<T>
infix fun <T : Path> Expect<T>.toHave(directoryEntries: DirectoryEntries): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.toHaveElementsAnd(noDuplicates: noDuplicates): Expect<T>
infix fun <E : Any, T : Iterable<E?>> Expect<T>.toHaveElementsAndAll(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <E : Any, T : Iterable<E?>> Expect<T>.toHaveElementsAndAny(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <E : Any, T : Iterable<E?>> Expect<T>.toHaveElementsAndNone(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <T : Collection<*>> Expect<T>.toHaveSize(expected: Int): Expect<T>
infix fun <T : Path> Expect<T>.toHaveTheSameBinaryContentAs(targetPath: Path): Expect<T>
infix fun <T : Path> Expect<T>.toHaveTheSameTextualContentAs(targetPath: Path): Expect<T>
infix fun <T : Path> Expect<T>.toHaveTheSameTextualContentAs(pathWithEncoding: PathWithEncoding): Expect<T>
infix fun <T : CharSequence> Expect<T>.toMatch(pattern: Regex): Expect<T>
infix fun <T : CharSequence> Expect<T>.toStartWith(expected: CharSequence): Expect<T>
infix fun <T : Path> Expect<T>.toStartWith(expected: Path): Expect<T>
inline fun <reified TExpected : Throwable> Expect<() -> Any?>.toThrow(): Expect<TExpected>
inline infix fun <reified TExpected : Throwable> Expect<() -> Any?>.toThrow(noinline assertionCreator: Expect<TExpected>.() -> Unit): Expect<TExpected>
infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>
@JvmName("valueIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>
fun <T> value(value: T): Value<T>
infix fun <E, T> IterableLikeContains.CheckerStep<E, T, InAnyOrderSearchBehaviour>.value(expected: E): Expect<T>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): Expect<T>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.value(expected: E): Expect<T>
infix fun <K, V, T : Entry<K, V>> Expect<T>.value(assertionCreator: Expect<V>.() -> Unit): Expect<T>
val <V, T : Entry<*, V>> Expect<T>.value: Expect<V>
fun <T> values(value: T, vararg otherValues: T): Values<T>
infix fun <K, V, T : Map<out K, V>> Expect<T>.values(assertionCreator: Expect<Collection<V>>.() -> Unit): Expect<T>
val <V, T : Map<*, V>> Expect<T>.values: Expect<Collection<V>>
fun withEncoding(path: Path, sourceCharset: Charset = Charsets.UTF_8, targetCharset: Charset = Charsets.UTF_8): PathWithEncoding
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedSearchBehaviour>.within(group: group): IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedWithinSearchBehaviour>
infix fun <T> RootExpect<T>.withOptions(configuration: RootExpectBuilder.OptionsChooser<T>.() -> Unit): Expect<T>
infix fun <T> RootExpect<T>.withOptions(options: RootExpectOptions<T>): Expect<T>
infix fun <T, R> FeatureExpect<T, R>.withOptions(configuration: FeatureExpectOptionsChooser<R>.() -> Unit): Expect<R>
infix fun <T, R> FeatureExpect<T, R>.withOptions(options: FeatureExpectOptions<R>): Expect<R>
infix fun <T> RootExpect<T>.withRepresentation(textRepresentation: String): Expect<T>
infix fun <T> RootExpect<T>.withRepresentation(representationProvider: (T) -> Any): Expect<T>
infix fun <T, R> FeatureExpect<T, R>.withRepresentation(textRepresentation: String): Expect<R>
infix fun <T, R> FeatureExpect<T, R>.withRepresentation(representationProvider: (R) -> Any): Expect<R>
object writable : Keyword
val Expect<LocalDate>.year: Expect<Int>
val Expect<LocalDateTime>.year: Expect<Int>
val Expect<ZonedDateTime>.year: Expect<Int>
infix fun Expect<LocalDate>.year(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDate>
infix fun Expect<LocalDateTime>.year(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDateTime>
infix fun Expect<ZonedDateTime>.year(assertionCreator: Expect<Int>.() -> Unit): Expect<ZonedDateTime>
package ch.tutteli.atrium.api.infix.en_GB.creating
package ch.tutteli.atrium.api.infix.en_GB.creating.feature
Module Contents
data class ExtractorWithCreator<T, R>
data class Feature<T, R>
data class FeatureWithCreator<T, R>
class MetaFeatureOption<T>
Module Contents
MetaFeatureOption(expect: Expect<T>)
fun <R> f(property: KProperty0<R>): MetaFeature<R>
fun <R> f(f: KFunction0<R>): MetaFeature<R>
fun <A1, R> f(f: KFunction1<A1, R>, a1: A1): MetaFeature<R>
fun <A1, A2, R> f(f: KFunction2<A1, A2, R>, a1: A1, a2: A2): MetaFeature<R>
fun <A1, A2, A3, R> f(f: KFunction3<A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): MetaFeature<R>
fun <A1, A2, A3, A4, R> f(f: KFunction4<A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): MetaFeature<R>
fun <A1, A2, A3, A4, A5, R> f(f: KFunction5<A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): MetaFeature<R>
fun <R> f0(f: KFunction0<R>): MetaFeature<R>
fun <A1, R> f1(f: KFunction1<A1, R>, a1: A1): MetaFeature<R>
fun <A1, A2, R> f2(f: KFunction2<A1, A2, R>, a1: A1, a2: A2): MetaFeature<R>
fun <A1, A2, A3, R> f3(f: KFunction3<A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): MetaFeature<R>
fun <A1, A2, A3, A4, R> f4(f: KFunction4<A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): MetaFeature<R>
fun <A1, A2, A3, A4, A5, R> f5(f: KFunction5<A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): MetaFeature<R>
fun <R> p(property: KProperty0<R>): MetaFeature<R>
data class MetaFeatureOptionWithCreator<T, R>
package ch.tutteli.atrium.api.infix.en_GB.creating.iterable
package ch.tutteli.atrium.api.infix.en_GB.creating.map
package ch.tutteli.atrium.api.infix.en_GB.creating.path
package ch.tutteli.atrium.api.infix.en_GB.kotlin_1_3
package ch.tutteli.atrium.api.infix.en_GB.workaround
package ch.tutteli.atrium.api.verbs
package ch.tutteli.atrium.assertions
package ch.tutteli.atrium.assertions.builders
Module Contents
val assertionBuilder: AssertionBuilder
interface AssertionBuilder
Module Contents
open fun createDescriptive(description: String, representation: Any?, test: () -> Boolean): DescriptiveAssertion
open fun createDescriptive(description: Translatable, representation: Any?, test: () -> Boolean): DescriptiveAssertion
open fun <T> createDescriptive(expect: Expect<T>, description: String, representation: Any?, test: (T) -> Boolean): DescriptiveAssertion
open fun <T> createDescriptive(expect: Expect<T>, description: Translatable, representation: Any?, test: (T) -> Boolean): DescriptiveAssertion
abstract fun <T : AssertionGroupType> customType(groupType: T): DefaultAssertionGroupBuilderOptions<T>
abstract val descriptive: Descriptive.HoldsOption
abstract val explanatory: Explanatory.ExplanationOption
abstract val explanatoryGroup: ExplanatoryAssertionGroupTypeOption
abstract val feature: DefaultAssertionGroupBuilderOptions<FeatureAssertionGroupType>
abstract val list: DefaultAssertionGroupBuilderOptions<ListAssertionGroupType>
abstract val representationOnly: RepresentationOnly.HoldsStep
abstract val summary: AssertionGroupDescriptionAndEmptyRepresentationOption<SummaryAssertionGroupType, AssertionsOption<SummaryAssertionGroupType, BasicAssertionGroupFinalStep>>
interface AssertionBuilderFinalStep<T : Assertion>
interface AssertionGroupDescriptionAndEmptyRepresentationOption<out T : AssertionGroupType, R>
interface AssertionGroupDescriptionAndRepresentationOption<out T : AssertionGroupType, R>
interface AssertionsOption<out T : AssertionGroupType, out R>
Module Contents
fun <T : AssertionGroupType, R> create(groupType: T, description: Translatable, representation: Any, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>
abstract val description: Translatable
fun <T : AssertionGroupType> factoryWithDefaultFinalStep(): (T, Translatable, Any) -> AssertionsOption<T, BasicAssertionGroupFinalStep>
abstract val groupType: T
abstract val representation: Any
open fun withAssertion(assertion: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion, assertion3: Assertion): R
abstract fun withAssertions(assertions: List<Assertion>): R
fun <T : AssertionGroupType> withDefaultFinalStepAndEmptyDescriptionAndRepresentation(groupType: T): AssertionsOption<T, BasicAssertionGroupFinalStep>
fun <T : AssertionGroupType, R> withEmptyDescriptionAndRepresentation(groupType: T, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>
interface BasicAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>
fun createShouldNotBeShownToUserWarning(): Assertion
typealias DefaultAssertionGroupBuilderOptions<T> = AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, BasicAssertionGroupFinalStep>>
interface Descriptive
interface DescriptiveAssertionWithFailureHint
interface Explanatory
interface ExplanatoryAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>
interface ExplanatoryAssertionGroupTypeOption
interface ExplanatoryGroup
val AssertionBuilder.fixedClaimGroup: FixedClaimGroup.GroupTypeOption
interface FixedClaimGroup
interface FixedClaimLikeGroup
val AssertionBuilder.invisibleGroup: AssertionsOption<InvisibleAssertionGroupType, BasicAssertionGroupFinalStep>
val AssertionBuilder.partiallyFixedClaimGroup: PartiallyFixedClaimGroup.GroupTypeOption
interface PartiallyFixedClaimGroup
interface RepresentationOnly
val AssertionBuilder.root: DefaultAssertionGroupBuilderOptions<RootAssertionGroupType>
interface SubjectBasedOption
Module Contents
interface AbsentOption<T, R>
interface DefinedOption<T, R, AO : SubjectBasedOption.AbsentOption<T, R>>
operator fun <T, R, PO : SubjectBasedOption.DefinedOption<T, R, *>> invoke(expect: Expect<T>, subStep: PO.() -> Pair<() -> R, (T) -> R>, presentOptionFactory: () -> PO): R
fun <T : ExplanatoryAssertionGroupType> AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>.withExplanatoryAssertion(translatable: Translatable): ExplanatoryAssertionGroupFinalStep
fun <T : ExplanatoryAssertionGroupType> AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>.withExplanatoryAssertion(representation: Any?): ExplanatoryAssertionGroupFinalStep
fun <T : ExplanatoryAssertionGroupType> AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>.withExplanatoryAssertion(translatable: Translatable, arg: Any, vararg otherArgs: Any): ExplanatoryAssertionGroupFinalStep
inline fun <T : ExplanatoryAssertionGroupType> AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>.withExplanatoryAssertion(explanationStep: (Explanatory.ExplanationOption) -> Assertion): ExplanatoryAssertionGroupFinalStep
fun <T : ExplanatoryAssertionGroupType> AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>.withExplanatoryAssertions(translatable: Translatable, arg: Any, vararg otherArgs: Any): ExplanatoryAssertionGroupFinalStep
fun Descriptive.DescriptionOption<Descriptive.FinalStep>.withFailureHint(failureHintFactory: () -> Assertion): DescriptiveAssertionWithFailureHint.ShowOption
fun <T> Descriptive.DescriptionOption<Descriptive.FinalStep>.withFailureHintBasedOnDefinedSubject(expect: Expect<T>, failureHintFactory: (T) -> Assertion): Descriptive.DescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>
fun <T> Descriptive.DescriptionOption<Descriptive.FinalStep>.withFailureHintBasedOnSubject(expect: Expect<T>, failureHintSubStep: DescriptiveAssertionWithFailureHint.FailureHintSubjectDefinedOption<T>.() -> Pair<() -> Assertion, (T) -> Assertion>): DescriptiveAssertionWithFailureHint.ShowOption
fun Descriptive.DescriptionOption<Descriptive.FinalStep>.withHelpOnFailure(failureHintFactory: () -> Assertion): DescriptiveAssertionWithFailureHint.ShowOption
fun <T> Descriptive.DescriptionOption<Descriptive.FinalStep>.withHelpOnFailureBasedOnDefinedSubject(expect: Expect<T>, failureHintFactory: (T) -> Assertion): Descriptive.DescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>
fun <T> Descriptive.DescriptionOption<Descriptive.FinalStep>.withHelpOnFailureBasedOnSubject(expect: Expect<T>, failureHintSubStep: DescriptiveAssertionWithFailureHint.FailureHintSubjectDefinedOption<T>.() -> Pair<() -> Assertion, (T) -> Assertion>): DescriptiveAssertionWithFailureHint.ShowOption
package ch.tutteli.atrium.assertions.builders.common
package ch.tutteli.atrium.core
Module Contents
val coreFactory: CoreFactory
expect interface CoreFactory : CoreFactoryCommon
interface CoreFactoryCommon
Module Contents
abstract fun newAssertionFormatterController(): AssertionFormatterController
abstract fun newAssertionFormatterFacade(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacade
abstract fun newDetailedObjectFormatter(translator: Translator): ObjectFormatter
abstract fun newLocaleOrderDecider(): LocaleOrderDecider
abstract fun newMethodCallFormatter(): MethodCallFormatter
abstract fun newMultiAtriumErrorAdjuster(firstAdjuster: AtriumErrorAdjuster, secondAdjuster: AtriumErrorAdjuster, otherAdjusters: List<AtriumErrorAdjuster>): AtriumErrorAdjuster
abstract fun newNoOpAtriumErrorAdjuster(): AtriumErrorAdjuster
abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade, atriumErrorAdjuster: AtriumErrorAdjuster): Reporter
abstract fun newRemoveAtriumFromAtriumErrorAdjuster(): AtriumErrorAdjuster
abstract fun newRemoveRunnerAtriumErrorAdjuster(): AtriumErrorAdjuster
abstract fun newTextExplanatoryAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController): AssertionFormatter
abstract fun newTextFallbackAssertionFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextFeatureAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextListAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextNextLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newTextSameLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newTextSummaryAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTranslator(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider, primaryLocale: Locale, fallbackLocales: List<Locale>): Translator
abstract fun registerTextAssertionFormatterCapabilities(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterFacade: AssertionFormatterFacade, textAssertionPairFormatter: AssertionPairFormatter, objectFormatter: ObjectFormatter, translator: Translator): Unit
sealed class Either<out L, out R>
@Target([AnnotationTarget.FUNCTION, AnnotationTarget.CLASS]) annotation class ExperimentalNewExpectTypes
val falseProvider: () -> Boolean
inline fun <L, R, T> Either<L, R>.flatMap(f: (R) -> Either<L, T>): Either<L, T>
inline fun <T> Option<T>.getOrElse(default: () -> T): T
data class Left<L> : Either<L, Nothing>
object None : Option<Nothing>
sealed class Option<out T>
data class Right<R> : Either<Nothing, R>
data class Some<T> : Option<T>
val trueProvider: () -> Boolean
package ch.tutteli.atrium.core.migration
package ch.tutteli.atrium.core.polyfills
package ch.tutteli.atrium.creating
Module Contents
interface AssertionContainer<T> : SubjectProvider<T>
inline fun <reified I : Any> ComponentFactoryContainer.build(): I
inline fun <reified I : Any> ComponentFactoryContainer.buildChained(): Sequence<I>
interface CollectingExpect<T> : Expect<T>
data class ComponentFactory
interface ComponentFactoryContainer
interface DelegatingExpect<T> : Expect<T>
enum class ErrorMessages : StringBasedTranslatable
interface Expect<T> : SubjectProvider<T>
interface ExpectInternal<T> : Expect<T>, AssertionContainer<T>
@DslMarker annotation class ExpectMarker
@Target([AnnotationTarget.FUNCTION, AnnotationTarget.CLASS, AnnotationTarget.PROPERTY, AnnotationTarget.LOCAL_VARIABLE]) annotation class ExperimentalComponentFactoryContainer
interface FeatureExpect<T, R> : Expect<R>
Module Contents
operator fun <T, R> invoke(previousExpect: Expect<T>, maybeSubject: Option<R>, description: Translatable, assertions: List<Assertion>, featureExpectOptions: FeatureExpectOptions<R>): FeatureExpect<T, R>
operator fun <T, R> invoke(featureExpect: FeatureExpect<T, R>, featureExpectOptions: FeatureExpectOptions<R>): FeatureExpect<T, R>
data class FeatureExpectOptions<R>
class PleaseUseReplacementException : Exception
interface RootExpect<T> : Expect<T>
data class RootExpectOptions<T>
interface SubjectProvider<out T>
package ch.tutteli.atrium.creating.feature
package ch.tutteli.atrium.creating.feature.impl
package ch.tutteli.atrium.creating.impl
package ch.tutteli.atrium.logic
Module Contents
inline val <T> Expect<T>._logic: AssertionContainer<T>
inline val <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>._logic: CharSequenceContains.EntryPointStepLogic<T, S>
inline val <T : CharSequence, S : CharSequenceContains.SearchBehaviour> WithTimesCheckerStep<T, S>._logic: WithTimesCheckerStepLogic<T, S>
inline val <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.CheckerStep<T, S>._logic: CharSequenceContains.CheckerStepLogic<T, S>
inline val <E, T : Any, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>._logic: IterableLikeContains.EntryPointStepLogic<E, T, S>
inline val <E, T : Any, S : IterableLikeContains.SearchBehaviour> WithTimesCheckerStep<E, T, S>._logic: WithTimesCheckerStepLogic<E, T, S>
inline val <E, T : Any, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.CheckerStep<E, T, S>._logic: IterableLikeContains.CheckerStepLogic<E, T, S>
inline val <K, V, T : Any, S : MapLikeContains.SearchBehaviour> MapLikeContains.EntryPointStep<K, V, T, S>._logic: MapLikeContains.EntryPointStepLogic<K, V, T, S>
inline fun <T> Expect<T>._logicAppend(assertionCreator: AssertionContainer<T>.() -> Assertion): Expect<T>
inline fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.CheckerStep<T, S>._logicAppend(factory: CharSequenceContains.CheckerStepLogic<T, S>.() -> Assertion): Expect<T>
inline fun <E, T : Any, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>._logicAppend(factory: IterableLikeContains.EntryPointStepLogic<E, T, S>.() -> Assertion): Expect<T>
inline fun <E, T : Any, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.CheckerStep<E, T, S>._logicAppend(factory: IterableLikeContains.CheckerStepLogic<E, T, S>.() -> Assertion): Expect<T>
inline fun <K, V, T : Any, S : MapLikeContains.SearchBehaviour> MapLikeContains.EntryPointStep<K, V, T, S>._logicAppend(factory: MapLikeContains.EntryPointStepLogic<K, V, T, S>.() -> Assertion): Expect<T>
interface AnyAssertions
Module Contents
abstract fun <T> because(container: AssertionContainer<T>, reason: String, assertionCreator: Expect<T>.() -> Unit): Assertion
abstract fun <T, TSub : Any> isA(container: AssertionContainer<T>, subType: KClass<TSub>): SubjectChangerBuilder.ExecutionStep<T, TSub>
abstract fun <T> isNotIn(container: AssertionContainer<T>, expected: Iterable<T>): Assertion
abstract fun <T> isNotSameAs(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T> isSameAs(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T> notToBe(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T : Any> notToBeNullButOfType(container: AssertionContainer<T?>, subType: KClass<T>): SubjectChangerBuilder.ExecutionStep<T?, T>
abstract fun <T> toBe(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T : Any> toBeNullIfNullGivenElse(container: AssertionContainer<T?>, assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Assertion
interface BigDecimalAssertions
val <T> AssertionContainer<T>.changeSubject: SubjectChangerBuilder.KindStep<T>
interface CharSequenceAssertions
interface ChronoLocalDateAssertions
Module Contents
abstract fun <T : ChronoLocalDate> isAfter(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isAfter(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDate> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDate> isBefore(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isBefore(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDate> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDate> isEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isEqual(container: AssertionContainer<T>, expected: String): Assertion
interface ChronoLocalDateTimeAssertions
Module Contents
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: String): Assertion
interface ChronoZonedDateTimeAssertions
Module Contents
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: String): Assertion
inline fun <T> AssertionContainer<T>.collect(noinline assertionCreator: Expect<T>.() -> Unit): Assertion
fun <T, R> TransformationExecutionStep<T, R, *>.collectAndLogicAppend(assertionCreator: AssertionContainer<R>.() -> Assertion): Expect<T>
inline fun <T> AssertionContainer<*>.collectBasedOnSubject(maybeSubject: Option<T>, noinline assertionCreator: Expect<T>.() -> Unit): Assertion
inline fun <T> AssertionContainer<T>.collectForComposition(noinline assertionCreator: Expect<T>.() -> Unit): List<Assertion>
inline fun <T> AssertionContainer<*>.collectForCompositionBasedOnSubject(maybeSubject: Option<T>, noinline assertionCreator: Expect<T>.() -> Unit): List<Assertion>
interface CollectionLikeAssertions
interface ComparableAssertions
Module Contents
abstract fun <T1 : Comparable<T2>, T2> isEqualComparingTo(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isGreaterThan(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isGreaterThanOrEqual(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isLessThan(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isLessThanOrEqual(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isNotGreaterThan(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isNotLessThan(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T> AssertionContainer<T>.createDescriptiveAssertion(description: Translatable, representation: Any?, test: (T) -> Boolean): Assertion
val <T> AssertionContainer<T>.extractFeature: FeatureExtractorBuilder.DescriptionStep<T>
interface FeatureAssertions
Module Contents
abstract fun <T, R> f0(container: AssertionContainer<T>, f: KFunction1<T, R>): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, R> f1(container: AssertionContainer<T>, f: KFunction2<T, A1, R>, a1: A1): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, A2, R> f2(container: AssertionContainer<T>, f: KFunction3<T, A1, A2, R>, a1: A1, a2: A2): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, A2, A3, R> f3(container: AssertionContainer<T>, f: KFunction4<T, A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, A2, A3, A4, R> f4(container: AssertionContainer<T>, f: KFunction5<T, A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, A2, A3, A4, A5, R> f5(container: AssertionContainer<T>, f: KFunction6<T, A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, R> manualFeature(container: AssertionContainer<T>, description: Translatable, provider: T.() -> R): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, TProperty> property(container: AssertionContainer<T>, property: KProperty1<in T, TProperty>): FeatureExtractorBuilder.ExecutionStep<T, TProperty>
interface FloatingPointAssertions
interface FloatingPointJvmAssertions
interface Fun0Assertions
fun <T, R> AssertionContainer<T>.genericSubjectBasedFeature(provider: (T) -> MetaFeature<R>): FeatureExtractorBuilder.ExecutionStep<T, R>
interface IterableLikeAssertions
Module Contents
abstract fun <T, E> all(container: AssertionContainer<T>, converter: (T) -> Iterable<E?>, assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Assertion
abstract fun <T, E> builderContainsInIterableLike(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>
abstract fun <T, E> builderContainsNotInIterableLike(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): NotCheckerStep<E, T, NotSearchBehaviour>
abstract fun <T, E> containsNoDuplicates(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
abstract fun <T, E> hasNext(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
abstract fun <T, E> hasNotNext(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
abstract fun <T, E : Comparable<E>> max(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): FeatureExtractorBuilder.ExecutionStep<T, E>
abstract fun <T, E : Comparable<E>> min(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): FeatureExtractorBuilder.ExecutionStep<T, E>
interface IteratorAssertions
interface ListAssertions
interface LocalDateAssertions
interface LocalDateTimeAssertions
fun <T, R> AssertionContainer<T>.manualFeature(description: String, provider: T.() -> R): FeatureExtractorBuilder.ExecutionStep<T, R>
interface MapEntryAssertions
Module Contents
abstract fun <K, V, T : Entry<K, V>> isKeyValue(container: AssertionContainer<T>, key: K, value: V): Assertion
abstract fun <K, T : Entry<K, *>> key(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, K>
abstract fun <V, T : Entry<*, V>> value(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, V>
interface MapLikeAssertions
Module Contents
abstract fun <T, K, V> builderContainsInMapLike(container: AssertionContainer<T>, converter: (T) -> Map<out K, V>): MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>
abstract fun <K, T> containsKey(container: AssertionContainer<T>, converter: (T) -> Map<out K, *>, key: K): Assertion
abstract fun <K, T> containsNotKey(container: AssertionContainer<T>, converter: (T) -> Map<out K, *>, key: K): Assertion
abstract fun <K, V, T> getExisting(container: AssertionContainer<T>, converter: (T) -> Map<out K, V>, key: K): FeatureExtractorBuilder.ExecutionStep<T, V>
interface OptionalAssertions
interface PairAssertions
interface PathAssertions
Module Contents
abstract fun <T : Path> endsNotWith(container: AssertionContainer<T>, expected: Path): Assertion
abstract fun <T : Path> endsWith(container: AssertionContainer<T>, expected: Path): Assertion
abstract fun <T : Path> exists(container: AssertionContainer<T>, linkOption: LinkOption? = null): Assertion
abstract fun <T : Path> existsNot(container: AssertionContainer<T>, linkOption: LinkOption? = null): Assertion
abstract fun <T : Path> extension(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
abstract fun <T : Path> fileName(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
abstract fun <T : Path> fileNameWithoutExtension(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
abstract fun <T : Path> hasDirectoryEntry(container: AssertionContainer<T>, entries: List<String>): Assertion
abstract fun <T : Path> hasSameBinaryContentAs(container: AssertionContainer<T>, targetPath: Path): Assertion
abstract fun <T : Path> hasSameTextualContentAs(container: AssertionContainer<T>, targetPath: Path, sourceCharset: Charset, targetCharset: Charset): Assertion
abstract fun <T : Path> isAbsolute(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isDirectory(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isEmptyDirectory(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isExecutable(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isNotExecutable(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isNotReadable(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isNotWritable(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isReadable(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isRegularFile(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isRelative(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isSymbolicLink(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isWritable(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> parent(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, Path>
abstract fun <T : Path> resolve(container: AssertionContainer<T>, other: String): FeatureExtractorBuilder.ExecutionStep<T, Path>
abstract fun <T : Path> startsNotWith(container: AssertionContainer<T>, expected: Path): Assertion
abstract fun <T : Path> startsWith(container: AssertionContainer<T>, expected: Path): Assertion
interface ThrowableAssertions
fun <T> Expect<T>.toAssertionContainer(): AssertionContainer<T>
fun <T> AssertionContainer<T>.toExpect(): Expect<T>
interface ZonedDateTimeAssertions
package ch.tutteli.atrium.logic.assertions.impl
package ch.tutteli.atrium.logic.creating
package ch.tutteli.atrium.logic.creating.basic.contains
Module Contents
interface Contains
Module Contents
interface Checker
interface CheckerStep<T : Any, out S : Contains.SearchBehaviour, out C : Contains.Checker, out B : Contains.EntryPointStep<T, S>>
interface CheckerStepLogic<T : Any, out S : Contains.SearchBehaviour, out C : Contains.Checker, out B : Contains.EntryPointStepLogic<T, S>>
interface Creator<T, in SC>
interface EntryPointStep<T : Any, out S : Contains.SearchBehaviour>
interface EntryPointStepLogic<T : Any, out S : Contains.SearchBehaviour>
interface SearchBehaviour
package ch.tutteli.atrium.logic.creating.basic.contains.checkers
package ch.tutteli.atrium.logic.creating.basic.contains.checkers.impl
package ch.tutteli.atrium.logic.creating.basic.contains.creators.impl
Module Contents
abstract class ContainsAssertionCreator<T : Any, TT : Any, in SC, C : Contains.Checker> : Contains.Creator<T, SC>
abstract class ContainsObjectsAssertionCreator<T : Any, TT : Any, in SC, S : Contains.SearchBehaviour, C : Contains.Checker> : ContainsAssertionCreator<T, TT, SC, C>
package ch.tutteli.atrium.logic.creating.basic.contains.steps.impl
package ch.tutteli.atrium.logic.creating.charsequence.contains
Module Contents
interface CharSequenceContains
Module Contents
interface Checker : Contains.Checker
interface CheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.CheckerStep<T, S, CharSequenceContains.Checker, CharSequenceContains.EntryPointStep<T, S>>
interface CheckerStepInternal<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStep<T, S>, CharSequenceContains.CheckerStepLogic<T, S>
interface CheckerStepLogic<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.CheckerStepLogic<T, S, CharSequenceContains.Checker, CharSequenceContains.EntryPointStepLogic<T, S>>
interface Creator<T : CharSequence, in SC> : Contains.Creator<T, SC>
interface EntryPointStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.EntryPointStep<T, S>
interface EntryPointStepInternal<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.EntryPointStep<T, S>, CharSequenceContains.EntryPointStepLogic<T, S>
interface EntryPointStepLogic<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.EntryPointStepLogic<T, S>
interface SearchBehaviour : Contains.SearchBehaviour
interface Searcher<S : CharSequenceContains.SearchBehaviour, SC>
package ch.tutteli.atrium.logic.creating.charsequence.contains.checkers
package ch.tutteli.atrium.logic.creating.charsequence.contains.checkers.impl
package ch.tutteli.atrium.logic.creating.charsequence.contains.creators
package ch.tutteli.atrium.logic.creating.charsequence.contains.creators.impl
package ch.tutteli.atrium.logic.creating.charsequence.contains.searchbehaviours
package ch.tutteli.atrium.logic.creating.charsequence.contains.searchbehaviours.impl
package ch.tutteli.atrium.logic.creating.charsequence.contains.searchers.impl
package ch.tutteli.atrium.logic.creating.charsequence.contains.steps
Module Contents
interface AtLeastCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStepLogic<T, S>.atLeastCheckerStep(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String): AtLeastCheckerStep<T, S>
interface AtMostCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStepLogic<T, S>.atMostCheckerStep(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String): AtMostCheckerStep<T, S>
interface ButAtMostCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> WithTimesCheckerStepLogic<T, S>.butAtMostCheckerStep(times: Int, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String, atMostCall: (Int) -> String): ButAtMostCheckerStep<T, S>
interface ExactlyCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStepLogic<T, S>.exactlyCheckerStep(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String): ExactlyCheckerStep<T, S>
val <T : CharSequence, S : NoOpSearchBehaviour> CharSequenceContains.EntryPointStepLogic<T, S>.ignoringCase: CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>
interface NotCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStep<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStepLogic<T, S>.notCheckerStep(): NotCheckerStep<T, S>
interface NotOrAtMostCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStep<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStepLogic<T, S>.notOrAtMostCheckerStep(times: Int, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String): NotOrAtMostCheckerStep<T, S>
interface WithTimesCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStep<T, S>
interface WithTimesCheckerStepInternal<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>, WithTimesCheckerStepLogic<T, S>, CharSequenceContains.CheckerStepInternal<T, S>
interface WithTimesCheckerStepLogic<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStepLogic<T, S>
package ch.tutteli.atrium.logic.creating.charsequence.contains.steps.impl
Module Contents
fun <T : CharSequence> atLeastChecker(container: AssertionContainer<T>, times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String): AtLeastChecker
fun <T : CharSequence> atMostChecker(container: AssertionContainer<T>, times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String): AtMostChecker
class AtMostCheckerStepImpl<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtMostCheckerStep<T, S>, CharSequenceContains.CheckerStepInternal<T, S>
class ButAtMostCheckerStepImpl<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ButAtMostCheckerStep<T, S>, CharSequenceContains.CheckerStepInternal<T, S>
Module Contents
ButAtMostCheckerStepImpl(times: Int, atLeastBuilder: WithTimesCheckerStepLogic<T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String, atMostCall: (Int) -> String, entryPointStepLogic: CharSequenceContains.EntryPointStepLogic<T, S>)
val checkers: List<CharSequenceContains.Checker>
val entryPointStepLogic: CharSequenceContains.EntryPointStepLogic<T, S>
class EntryPointStepImpl<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : EntryPointStepImpl<T, S>, CharSequenceContains.EntryPointStepInternal<T, S>
class GenericTimesCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStepInternal<T, S>, AtLeastCheckerStep<T, S>, ButAtMostCheckerStep<T, S>, ExactlyCheckerStep<T, S>
class NotCheckerStepImpl<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotCheckerStep<T, S>, CharSequenceContains.CheckerStepInternal<T, S>
class NotOrAtMostCheckerStepImpl<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotOrAtMostCheckerStep<T, S>, CharSequenceContains.CheckerStepInternal<T, S>
package ch.tutteli.atrium.logic.creating.collectors
package ch.tutteli.atrium.logic.creating.feature
package ch.tutteli.atrium.logic.creating.filesystem
package ch.tutteli.atrium.logic.creating.filesystem.hints
package ch.tutteli.atrium.logic.creating.impl
package ch.tutteli.atrium.logic.creating.iterable.contains
Module Contents
interface IterableLikeContains
Module Contents
interface Checker : Contains.Checker
interface CheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : Contains.CheckerStep<T, S, IterableLikeContains.Checker, IterableLikeContains.EntryPointStep<E, T, S>>
interface CheckerStepInternal<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStep<E, T, S>, IterableLikeContains.CheckerStepLogic<E, T, S>
interface CheckerStepLogic<E, T, out S : IterableLikeContains.SearchBehaviour> : Contains.CheckerStepLogic<T, S, IterableLikeContains.Checker, IterableLikeContains.EntryPointStepLogic<E, T, S>>
interface Creator<T, in SC> : Contains.Creator<T, SC>
interface EntryPointStep<E, T, out S : IterableLikeContains.SearchBehaviour> : Contains.EntryPointStep<T, S>
interface EntryPointStepInternal<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.EntryPointStep<E, T, S>, IterableLikeContains.EntryPointStepLogic<E, T, S>
interface EntryPointStepLogic<E, T, out S : IterableLikeContains.SearchBehaviour> : Contains.EntryPointStepLogic<T, S>
interface SearchBehaviour : Contains.SearchBehaviour
package ch.tutteli.atrium.logic.creating.iterable.contains.checkers
package ch.tutteli.atrium.logic.creating.iterable.contains.checkers.impl
package ch.tutteli.atrium.logic.creating.iterable.contains.creators
Module Contents
interface IterableLikeContainsAssertions
Module Contents
abstract fun <E : Any, T> entriesInAnyOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
abstract fun <E : Any, T> entriesInOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
abstract fun <E : Any, T> entriesInOrderOnlyGrouped(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<(Expect<E>.() -> Unit)?>>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
abstract fun <E, T> valuesInAnyOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T> valuesInOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlySearchBehaviour>, expected: List<E>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
abstract fun <E, T> valuesInOrderOnlyGrouped(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
interface IterableLikeContainsInAnyOrderAssertions
package ch.tutteli.atrium.logic.creating.iterable.contains.creators.impl
Module Contents
class DefaultIterableLikeContainsAssertions : IterableLikeContainsAssertions
Module Contents
DefaultIterableLikeContainsAssertions()
fun <E : Any, T> entriesInAnyOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
fun <E : Any, T> entriesInOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
fun <E : Any, T> entriesInOrderOnlyGrouped(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<(Expect<E>.() -> Unit)?>>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
fun <E, T> valuesInAnyOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): Assertion
fun <E, T> valuesInOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlySearchBehaviour>, expected: List<E>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
fun <E, T> valuesInOrderOnlyGrouped(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
class DefaultIterableLikeContainsInAnyOrderAssertions : IterableLikeContainsInAnyOrderAssertions
class InAnyOrderEntriesAssertionCreator<E : Any, T> : ContainsAssertionCreator<T, List<E?>, (Expect<E>.() -> Unit)?, IterableLikeContains.Checker>, IterableLikeContains.Creator<T, (Expect<E>.() -> Unit)?>
abstract class InAnyOrderOnlyAssertionCreator<E, T, in SC> : IterableLikeContains.Creator<T, SC>
class InAnyOrderOnlyEntriesAssertionCreator<E : Any, T> : InAnyOrderOnlyAssertionCreator<E?, T, (Expect<E>.() -> Unit)?>
class InAnyOrderOnlyValuesAssertionCreator<E, T> : InAnyOrderOnlyAssertionCreator<E, T, E>
class InAnyOrderValuesAssertionCreator<SC, T> : ContainsObjectsAssertionCreator<T, List<SC>, SC, InAnyOrderSearchBehaviour, IterableLikeContains.Checker>, IterableLikeContains.Creator<T, SC>
abstract class InOrderOnlyAssertionCreator<E, T, SC> : InOrderOnlyBaseAssertionCreator<E, T, SC>, InOrderOnlyMatcher<E, SC>
abstract class InOrderOnlyBaseAssertionCreator<E, T, SC> : IterableLikeContains.Creator<T, SC>
class InOrderOnlyEntriesAssertionCreator<E : Any, T> : InOrderOnlyAssertionCreator<E?, T, (Expect<E>.() -> Unit)?>, InOrderOnlyMatcher<E?, (Expect<E>.() -> Unit)?>
class InOrderOnlyEntriesMatcher<E : Any> : InOrderOnlyMatcher<E?, (Expect<E>.() -> Unit)?>
abstract class InOrderOnlyGroupedAssertionCreator<E, T, SC> : InOrderOnlyBaseAssertionCreator<E, T, List<SC>>, InOrderOnlyMatcher<E, SC>
class InOrderOnlyGroupedEntriesAssertionCreator<E : Any, T> : InOrderOnlyGroupedAssertionCreator<E?, T, (Expect<E>.() -> Unit)?>, InOrderOnlyMatcher<E?, (Expect<E>.() -> Unit)?>
class InOrderOnlyGroupedValuesAssertionCreator<E, T> : InOrderOnlyGroupedAssertionCreator<E, T, E>, InOrderOnlyMatcher<E, E>
interface InOrderOnlyMatcher<E, SC>
class InOrderOnlyValueMatcher<E> : InOrderOnlyMatcher<E, E>
class InOrderOnlyValuesAssertionCreator<E, T> : InOrderOnlyAssertionCreator<E, T, E>, InOrderOnlyMatcher<E, E>
fun <E, T> turnSubjectToList(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): AssertionContainer<List<E>>
package ch.tutteli.atrium.logic.creating.iterable.contains.searchbehaviours
package ch.tutteli.atrium.logic.creating.iterable.contains.searchbehaviours.impl
package ch.tutteli.atrium.logic.creating.iterable.contains.steps
Module Contents
val <E, T> IterableLikeContains.EntryPointStepLogic<E, T, InOrderSearchBehaviour>.andOnly: IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>
interface AtLeastCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>
fun <E, T, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.EntryPointStepLogic<E, T, S>.atLeastCheckerStep(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String): AtLeastCheckerStep<E, T, S>
interface AtMostCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>
fun <E, T, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.EntryPointStepLogic<E, T, S>.atMostCheckerStep(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String): AtMostCheckerStep<E, T, S>
interface ButAtMostCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>
fun <E, T, S : IterableLikeContains.SearchBehaviour> WithTimesCheckerStepLogic<E, T, S>.butAtMostCheckerStep(times: Int, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String, atMostCall: (Int) -> String): ButAtMostCheckerStep<E, T, S>
val <E, T> IterableLikeContains.EntryPointStepLogic<E, T, InAnyOrderSearchBehaviour>.butOnly: IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>
interface ExactlyCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>
fun <E, T, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.EntryPointStepLogic<E, T, S>.exactlyCheckerStep(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String): ExactlyCheckerStep<E, T, S>
val <E, T> IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlySearchBehaviour>.grouped: IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedSearchBehaviour>
val <E, T> IterableLikeContains.EntryPointStepLogic<E, T, NoOpSearchBehaviour>.inAnyOrder: IterableLikeContains.EntryPointStep<E, T, InAnyOrderSearchBehaviour>
val <E, T> IterableLikeContains.EntryPointStepLogic<E, T, NoOpSearchBehaviour>.inOrder: IterableLikeContains.EntryPointStep<E, T, InOrderSearchBehaviour>
class NoOpCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStepInternal<E, T, S>
interface NotCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStep<E, T, S>
fun <E, T, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.EntryPointStepLogic<E, T, S>.notCheckerStep(): NotCheckerStep<E, T, S>
interface NotOrAtMostCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStep<E, T, S>
fun <E, T, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.EntryPointStepLogic<E, T, S>.notOrAtMostCheckerStep(times: Int, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String): NotOrAtMostCheckerStep<E, T, S>
val <E, T> IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlyGroupedSearchBehaviour>.within: IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedWithinSearchBehaviour>
interface WithTimesCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStep<E, T, S>
interface WithTimesCheckerStepInternal<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>, WithTimesCheckerStepLogic<E, T, S>, IterableLikeContains.CheckerStepInternal<E, T, S>
interface WithTimesCheckerStepLogic<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStepLogic<E, T, S>
package ch.tutteli.atrium.logic.creating.iterable.contains.steps.impl
Module Contents
fun <T> atLeastChecker(container: AssertionContainer<T>, times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String): AtLeastChecker
fun <T> atMostChecker(container: AssertionContainer<T>, times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String): AtMostChecker
class EntryPointStepImpl<E, T, out S : IterableLikeContains.SearchBehaviour> : EntryPointStepImpl<T, S>, IterableLikeContains.EntryPointStepInternal<E, T, S>
package ch.tutteli.atrium.logic.creating.iterablelike.contains.reporting
package ch.tutteli.atrium.logic.creating.maplike.contains
Module Contents
interface MapLikeContains
Module Contents
interface Checker : Contains.Checker
interface Creator<T, in SC> : Contains.Creator<T, SC>
interface EntryPointStep<K, V, T, out S : MapLikeContains.SearchBehaviour> : Contains.EntryPointStep<T, S>
interface EntryPointStepInternal<K, V, T, out S : MapLikeContains.SearchBehaviour> : MapLikeContains.EntryPointStep<K, V, T, S>, MapLikeContains.EntryPointStepLogic<K, V, T, S>
interface EntryPointStepLogic<K, V, T, out S : MapLikeContains.SearchBehaviour> : Contains.EntryPointStepLogic<T, S>
interface SearchBehaviour : Contains.SearchBehaviour
package ch.tutteli.atrium.logic.creating.maplike.contains.checkers
package ch.tutteli.atrium.logic.creating.maplike.contains.checkers.impl
package ch.tutteli.atrium.logic.creating.maplike.contains.creators
Module Contents
interface MapLikeContainsAssertions
Module Contents
abstract fun <K, V, T> keyValuePairsInAnyOrder(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InAnyOrderSearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
abstract fun <K, V, T> keyValuePairsInAnyOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InAnyOrderOnlySearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
abstract fun <K, V, T> keyValuePairsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InOrderOnlySearchBehaviour>, keyValuePairs: List<Pair<K, V>>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
abstract fun <K, V : Any, T> keyWithValueAssertionsInAnyOrder(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InAnyOrderSearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
abstract fun <K, V : Any, T> keyWithValueAssertionsInAnyOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InAnyOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
abstract fun <K, V : Any, T> keyWithValueAssertionsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
abstract fun <K, V : Any, T> keyWithValueAssertionsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
package ch.tutteli.atrium.logic.creating.maplike.contains.creators.impl
Module Contents
class DefaultMapLikeContainsAssertions : MapLikeContainsAssertions
Module Contents
DefaultMapLikeContainsAssertions()
fun <K, V, T> keyValuePairsInAnyOrder(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InAnyOrderSearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
fun <K, V, T> keyValuePairsInAnyOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InAnyOrderOnlySearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
fun <K, V, T> keyValuePairsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InOrderOnlySearchBehaviour>, keyValuePairs: List<Pair<K, V>>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
fun <K, V : Any, T> keyWithValueAssertionsInAnyOrder(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InAnyOrderSearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
fun <K, V : Any, T> keyWithValueAssertionsInAnyOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InAnyOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
fun <K, V : Any, T> keyWithValueAssertionsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
fun <K, V : Any, T> keyWithValueAssertionsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>, reportingOptions: InOrderOnlyReportingOptions.() -> Unit): Assertion
package ch.tutteli.atrium.logic.creating.maplike.contains.searchbehaviours
package ch.tutteli.atrium.logic.creating.maplike.contains.searchbehaviours.impl
package ch.tutteli.atrium.logic.creating.maplike.contains.steps
Module Contents
val <K, V, T> MapLikeContains.EntryPointStepLogic<K, V, T, InOrderSearchBehaviour>.andOnly: MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>
val <K, V, T> MapLikeContains.EntryPointStepLogic<K, V, T, InAnyOrderSearchBehaviour>.butOnly: MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>
val <K, V, T> MapLikeContains.EntryPointStepLogic<K, V, T, NoOpSearchBehaviour>.inAnyOrder: MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>
val <K, V, T> MapLikeContains.EntryPointStepLogic<K, V, T, NoOpSearchBehaviour>.inOrder: MapLikeContains.EntryPointStep<K, V, T, InOrderSearchBehaviour>
package ch.tutteli.atrium.logic.creating.maplike.contains.steps.impl
package ch.tutteli.atrium.logic.creating.transformers
Module Contents
class FailureHandlerAdapter<T, R1, R> : SubjectChanger.FailureHandler<T, R>
interface FeatureExtractor
val <T> AssertionContainer<T>.featureExtractor: FeatureExtractor
interface FeatureExtractorBuilder
interface SubjectChanger
Module Contents
interface FailureHandler<T, R>
abstract fun <T, R> reported(container: AssertionContainer<T>, description: Translatable, representation: Any, transformation: (T) -> Option<R>, failureHandler: SubjectChanger.FailureHandler<T, R>, maybeSubAssertions: Option<Expect<R>.() -> Unit>): Expect<R>
abstract fun <T, R> unreported(container: AssertionContainer<T>, transformation: (T) -> R): Expect<R>
val <T> AssertionContainer<T>.subjectChanger: SubjectChanger
interface SubjectChangerBuilder
Module Contents
interface DescriptionRepresentationStep<T>
interface ExecutionStep<T, R> : TransformationExecutionStep<T, R, Expect<R>>
interface FailureHandlerStep<T, R>
Module Contents
open fun build(): SubjectChangerBuilder.ExecutionStep<T, R>
operator fun <T, R> invoke(transformationStep: SubjectChangerBuilder.TransformationStep<T>, transformation: (T) -> Option<R>): SubjectChangerBuilder.FailureHandlerStep<T, R>
abstract val transformation: (T) -> Option<R>
abstract val transformationStep: SubjectChangerBuilder.TransformationStep<T>
abstract fun withDefaultFailureHandler(): SubjectChangerBuilder.FinalStep<T, R>
abstract fun withFailureHandler(failureHandler: SubjectChanger.FailureHandler<T, R>): SubjectChangerBuilder.FinalStep<T, R>
open fun <R1> withFailureHandlerAdapter(failureHandler: SubjectChanger.FailureHandler<R1, R>, map: (T) -> R1): SubjectChangerBuilder.FinalStep<T, R>
interface FinalStep<T, R>
operator fun <T> invoke(container: AssertionContainer<T>): SubjectChangerBuilder.KindStep<T>
interface KindStep<T>
interface TransformationStep<T>
interface TransformationExecutionStep<T, R, E : Expect<R>>
package ch.tutteli.atrium.logic.creating.transformers.impl
package ch.tutteli.atrium.logic.creating.transformers.impl.featureextractor
Module Contents
class DescriptionStepImpl<T> : FeatureExtractorBuilder.DescriptionStep<T>
class ExecutionStepImpl<T, R> : FeatureExtractorBuilder.ExecutionStep<T, R>, BaseTransformationExecutionStep<T, R, FeatureExpect<T, R>>
class FeatureExtractionStepImpl<T> : FeatureExtractorBuilder.FeatureExtractionStep<T>
class FinalStepImpl<T, R> : FeatureExtractorBuilder.FinalStep<T, R>
class OptionsStepImpl<T, R> : FeatureExtractorBuilder.OptionsStep<T, R>
package ch.tutteli.atrium.logic.creating.transformers.impl.subjectchanger
Module Contents
class DefaultFailureHandlerImpl<T, R> : SubjectChanger.FailureHandler<T, R>
class DescriptionRepresentationStepImpl<T> : SubjectChangerBuilder.DescriptionRepresentationStep<T>
class ExecutionStepImpl<T, R> : SubjectChangerBuilder.ExecutionStep<T, R>, BaseTransformationExecutionStep<T, R, Expect<R>>
class FailureHandlerStepImpl<T, R> : SubjectChangerBuilder.FailureHandlerStep<T, R>
class FinalStepImpl<T, R> : SubjectChangerBuilder.FinalStep<T, R>
class KindStepImpl<T> : SubjectChangerBuilder.KindStep<T>
class TransformationStepImpl<T> : SubjectChangerBuilder.TransformationStep<T>
package ch.tutteli.atrium.logic.creating.typeutils
package ch.tutteli.atrium.logic.creating.typeutils.impl
package ch.tutteli.atrium.logic.impl
Module Contents
class DefaultAnyAssertions : AnyAssertions
Module Contents
DefaultAnyAssertions()
fun <T> because(container: AssertionContainer<T>, reason: String, assertionCreator: Expect<T>.() -> Unit): Assertion
fun <T, TSub : Any> isA(container: AssertionContainer<T>, subType: KClass<TSub>): SubjectChangerBuilder.ExecutionStep<T, TSub>
fun <T> isNotIn(container: AssertionContainer<T>, expected: Iterable<T>): Assertion
fun <T> isNotSameAs(container: AssertionContainer<T>, expected: T): Assertion
fun <T> isSameAs(container: AssertionContainer<T>, expected: T): Assertion
fun <T> notToBe(container: AssertionContainer<T>, expected: T): Assertion
fun <T : Any> notToBeNullButOfType(container: AssertionContainer<T?>, subType: KClass<T>): SubjectChangerBuilder.ExecutionStep<T?, T>
fun <T> toBe(container: AssertionContainer<T>, expected: T): Assertion
fun <T : Any> toBeNullIfNullGivenElse(container: AssertionContainer<T?>, assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Assertion
class DefaultBigDecimalAssertions : BigDecimalAssertions
class DefaultCharSequenceAssertions : CharSequenceAssertions
class DefaultChronoLocalDateAssertions : ChronoLocalDateAssertions
Module Contents
DefaultChronoLocalDateAssertions()
fun <T : ChronoLocalDate> isAfter(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isAfter(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDate> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDate> isBefore(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isBefore(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDate> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDate> isEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isEqual(container: AssertionContainer<T>, expected: String): Assertion
class DefaultChronoLocalDateTimeAssertions : ChronoLocalDateTimeAssertions
Module Contents
DefaultChronoLocalDateTimeAssertions()
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: String): Assertion
class DefaultChronoZonedDateTimeAssertions : ChronoZonedDateTimeAssertions
Module Contents
DefaultChronoZonedDateTimeAssertions()
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: String): Assertion
class DefaultCollectionLikeAssertions : CollectionLikeAssertions
class DefaultComparableAssertions : ComparableAssertions
Module Contents
DefaultComparableAssertions()
fun <T1 : Comparable<T2>, T2> isEqualComparingTo(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isGreaterThan(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isGreaterThanOrEqual(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isLessThan(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isLessThanOrEqual(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isNotGreaterThan(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isNotLessThan(container: AssertionContainer<T1>, expected: T2): Assertion
class DefaultFeatureAssertions : FeatureAssertions
Module Contents
DefaultFeatureAssertions()
fun <T, R> f0(container: AssertionContainer<T>, f: KFunction1<T, R>): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, R> f1(container: AssertionContainer<T>, f: KFunction2<T, A1, R>, a1: A1): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, A2, R> f2(container: AssertionContainer<T>, f: KFunction3<T, A1, A2, R>, a1: A1, a2: A2): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, A2, A3, R> f3(container: AssertionContainer<T>, f: KFunction4<T, A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, A2, A3, A4, R> f4(container: AssertionContainer<T>, f: KFunction5<T, A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, A2, A3, A4, A5, R> f5(container: AssertionContainer<T>, f: KFunction6<T, A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, R> manualFeature(container: AssertionContainer<T>, description: Translatable, provider: T.() -> R): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, TProperty> property(container: AssertionContainer<T>, property: KProperty1<in T, TProperty>): FeatureExtractorBuilder.ExecutionStep<T, TProperty>
class DefaultFloatingPointAssertions : FloatingPointAssertions
class DefaultFloatingPointJvmAssertions : FloatingPointJvmAssertions
class DefaultFun0Assertions : Fun0Assertions
class DefaultIterableLikeAssertions : IterableLikeAssertions
Module Contents
DefaultIterableLikeAssertions()
fun <T, E> all(container: AssertionContainer<T>, converter: (T) -> Iterable<E?>, assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Assertion
fun <T, E> builderContainsInIterableLike(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>
fun <T, E> builderContainsNotInIterableLike(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): NotCheckerStep<E, T, NotSearchBehaviour>
fun <T, E> containsNoDuplicates(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
fun <T, E> hasNext(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
fun <T, E> hasNotNext(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
fun <T, E : Comparable<E>> max(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): FeatureExtractorBuilder.ExecutionStep<T, E>
fun <T, E : Comparable<E>> min(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): FeatureExtractorBuilder.ExecutionStep<T, E>
class DefaultIteratorAssertions : IteratorAssertions
class DefaultListAssertions : ListAssertions
class DefaultLocalDateAssertions : LocalDateAssertions
class DefaultLocalDateTimeAssertions : LocalDateTimeAssertions
class DefaultMapEntryAssertions : MapEntryAssertions
Module Contents
DefaultMapEntryAssertions()
fun <K, V, T : Entry<K, V>> isKeyValue(container: AssertionContainer<T>, key: K, value: V): Assertion
fun <K, T : Entry<K, *>> key(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, K>
fun <V, T : Entry<*, V>> value(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, V>
class DefaultMapLikeAssertions : MapLikeAssertions
Module Contents
DefaultMapLikeAssertions()
fun <T, K, V> builderContainsInMapLike(container: AssertionContainer<T>, converter: (T) -> Map<out K, V>): MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>
fun <K, T> containsKey(container: AssertionContainer<T>, converter: (T) -> Map<out K, *>, key: K): Assertion
fun <K, T> containsNotKey(container: AssertionContainer<T>, converter: (T) -> Map<out K, *>, key: K): Assertion
fun <K, V, T> getExisting(container: AssertionContainer<T>, converter: (T) -> Map<out K, V>, key: K): FeatureExtractorBuilder.ExecutionStep<T, V>
class DefaultOptionalAssertions : OptionalAssertions
class DefaultPairAssertions : PairAssertions
class DefaultPathAssertions : PathAssertions
Module Contents
DefaultPathAssertions()
fun <T : Path> endsNotWith(container: AssertionContainer<T>, expected: Path): Assertion
fun <T : Path> endsWith(container: AssertionContainer<T>, expected: Path): Assertion
fun <T : Path> exists(container: AssertionContainer<T>, linkOption: LinkOption?): Assertion
fun <T : Path> existsNot(container: AssertionContainer<T>, linkOption: LinkOption?): Assertion
fun <T : Path> extension(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
fun <T : Path> fileName(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
fun <T : Path> fileNameWithoutExtension(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
fun <T : Path> hasDirectoryEntry(container: AssertionContainer<T>, entries: List<String>): Assertion
fun <T : Path> hasSameBinaryContentAs(container: AssertionContainer<T>, targetPath: Path): Assertion
fun <T : Path> hasSameTextualContentAs(container: AssertionContainer<T>, targetPath: Path, sourceCharset: Charset, targetCharset: Charset): Assertion
fun <T : Path> isAbsolute(container: AssertionContainer<T>): Assertion
fun <T : Path> isDirectory(container: AssertionContainer<T>): Assertion
fun <T : Path> isEmptyDirectory(container: AssertionContainer<T>): Assertion
fun <T : Path> isExecutable(container: AssertionContainer<T>): Assertion
fun <T : Path> isNotExecutable(container: AssertionContainer<T>): Assertion
fun <T : Path> isNotReadable(container: AssertionContainer<T>): Assertion
fun <T : Path> isNotWritable(container: AssertionContainer<T>): Assertion
fun <T : Path> isReadable(container: AssertionContainer<T>): Assertion
fun <T : Path> isRegularFile(container: AssertionContainer<T>): Assertion
fun <T : Path> isRelative(container: AssertionContainer<T>): Assertion
fun <T : Path> isSymbolicLink(container: AssertionContainer<T>): Assertion
fun <T : Path> isWritable(container: AssertionContainer<T>): Assertion
fun <T : Path> parent(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, Path>
fun <T : Path> resolve(container: AssertionContainer<T>, other: String): FeatureExtractorBuilder.ExecutionStep<T, Path>
fun <T : Path> startsNotWith(container: AssertionContainer<T>, expected: Path): Assertion
fun <T : Path> startsWith(container: AssertionContainer<T>, expected: Path): Assertion
class DefaultThrowableAssertions : ThrowableAssertions
class DefaultZonedDateTimeAssertions : ZonedDateTimeAssertions
package ch.tutteli.atrium.logic.kotlin_1_3
package ch.tutteli.atrium.logic.kotlin_1_3.impl
package ch.tutteli.atrium.logic.utils
Module Contents
class ArgumentMapperBuilder<out T>
class ArgumentToNullOrMapperBuilder<T : Any>
inline fun <T> expectLambda(noinline assertionCreator: Expect<T>.() -> Unit): Expect<T>.() -> Unit
interface Group<out T>
fun <T> groupsToList(firstGroup: Group<T>, secondGroup: Group<T>, otherGroups: Array<out Group<T>>): List<List<T>>
fun <T> AssertionContainer<*>.iterableLikeToIterable(iterableLike: IterableLike): Iterable<T>
fun <T> AssertionContainer<*>.iterableLikeToIterableWithoutCheckForElements(iterableLike: IterableLike): Iterable<T>
fun <T> mapArguments(first: T, others: Array<out T>): ArgumentMapperBuilder<T>
inline fun <T, reified R> mapArguments(first: T, others: Array<out T>, mapper: (T) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Byte, others: ByteArray): ArgumentMapperBuilder<Byte>
inline fun <reified R> mapArguments(first: Byte, others: ByteArray, mapper: (Byte) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Char, others: CharArray): ArgumentMapperBuilder<Char>
inline fun <reified R> mapArguments(first: Char, others: CharArray, mapper: (Char) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Short, others: ShortArray): ArgumentMapperBuilder<Short>
inline fun <reified R> mapArguments(first: Short, others: ShortArray, mapper: (Short) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Int, others: IntArray): ArgumentMapperBuilder<Int>
inline fun <reified R> mapArguments(first: Int, others: IntArray, mapper: (Int) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Long, others: LongArray): ArgumentMapperBuilder<Long>
inline fun <reified R> mapArguments(first: Long, others: LongArray, mapper: (Long) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Float, others: FloatArray): ArgumentMapperBuilder<Float>
inline fun <reified R> mapArguments(first: Float, others: FloatArray, mapper: (Float) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Double, others: DoubleArray): ArgumentMapperBuilder<Double>
inline fun <reified R> mapArguments(first: Double, others: DoubleArray, mapper: (Double) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Boolean, others: BooleanArray): ArgumentMapperBuilder<Boolean>
inline fun <reified R> mapArguments(first: Boolean, others: BooleanArray, mapper: (Boolean) -> R): Pair<R, Array<out R>>
fun <K, V> AssertionContainer<*>.mapLikeToIterablePair(mapLike: MapLike): List<Pair<K, V>>
fun <K, V> AssertionContainer<*>.mapLikeToVarArgPairs(mapLike: MapLike): Pair<Pair<K, V>, Array<out Pair<K, V>>>
inline fun <T> nullable(t: T): T?
inline fun <T> nullable(t: KFunction0<T>): KFunction0<T?>
@JvmName("nullable1") inline fun <T1, R> nullable(t: KFunction1<T1, R>): KFunction1<T1, R?>
@JvmName("nullable2") inline fun <T1, T2, R> nullable(t: KFunction2<T1, T2, R>): KFunction2<T1, T2, R?>
@JvmName("nullable3") inline fun <T1, T2, T3, R> nullable(t: KFunction3<T1, T2, T3, R>): KFunction3<T1, T2, T3, R?>
@JvmName("nullable4") inline fun <T1, T2, T3, T4, R> nullable(t: KFunction4<T1, T2, T3, T4, R>): KFunction4<T1, T2, T3, T4, R?>
@JvmName("nullable5") inline fun <T1, T2, T3, T4, T5, R> nullable(t: KFunction5<T1, T2, T3, T4, T5, R>): KFunction5<T1, T2, T3, T4, T5, R?>
inline fun <T> nullableContainer(iterable: Iterable<T>): Iterable<T?>
inline fun <T> nullableContainer(arr: Array<out T>): Array<out T?>
inline fun <K, V : Any> nullableKeyMap(map: Map<out K, V>): Map<out K?, V>
inline fun <K, V> nullableKeyValueMap(map: Map<out K, V>): Map<out K?, V?>
inline fun <K : Any, V> nullableValueMap(map: Map<K, V>): Map<K, V?>
fun <T : Any> ArgumentMapperBuilder<T?>.toNullOr(): ArgumentToNullOrMapperBuilder<T>
inline fun <reified T> CharSequenceContains.CheckerStepLogic<*, *>.toVarArg(iterableLike: IterableLike): Pair<T, Array<out T>>
inline fun <reified T> CharSequenceContains.EntryPointStepLogic<*, *>.toVarArg(iterableLike: IterableLike): Pair<T, Array<out T>>
inline fun <reified T> IterableLikeContains.CheckerStepLogic<*, *, *>.toVarArg(iterableLike: IterableLike): Pair<T, Array<out T>>
inline fun <reified T> IterableLikeContains.EntryPointStepLogic<*, *, *>.toVarArg(iterableLike: IterableLike): Pair<T, Array<out T>>
fun <K, V> MapLikeContains.EntryPointStepLogic<*, *, *, *>.toVarArgPairs(mapLike: MapLike): Pair<Pair<K, V>, Array<out Pair<K, V>>>
interface VarArgHelper<out T>
package ch.tutteli.atrium.reporting
package ch.tutteli.atrium.reporting.erroradjusters
package ch.tutteli.atrium.reporting.erroradjusters.impl
package ch.tutteli.atrium.reporting.impl
package ch.tutteli.atrium.reporting.text
package ch.tutteli.atrium.reporting.text.impl
package ch.tutteli.atrium.reporting.translating
package ch.tutteli.atrium.reporting.translating.impl
package ch.tutteli.atrium.translations